C# HashTable.Find方法代码示例

        public static void Main()
        {
            var hashtable = new HashTable<int, string>();
            hashtable.Add(5, "five");
            hashtable.Add(3, "tree");
            hashtable.Add(-6, "minus six");
            Console.WriteLine(hashtable.Find(-6));
            Console.WriteLine("All elements");
            foreach (var item in hashtable)
            {
                Console.WriteLine("Key: {0} => Value: {1}", item.Key, item.Value);
            }

            hashtable.Remove(3);
            Console.WriteLine("3 removed from table");
            try
            {
                Console.WriteLine("Searching for 3 in table");
                hashtable.Find(3);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }

            Console.WriteLine("Hash table has {0} elements", hashtable.Count);
        }

 public void HashTableTest()
 {
     HashTable<string, int> table = new HashTable<string, int>(100);
     table.Add("brad", 100);
     table.Add("rich", 200);
     table.Remove("rich");
     Assert.AreEqual(100, table.Find("brad"));
     Assert.AreEqual(0, table.Find("rich"));
 }

    private static void Main()
    {
        HashTable<string, int> myDictionary = new HashTable<string, int>();

        // Add method test
        myDictionary.Add("kir4o", 5);
        myDictionary.Add("gery", 3);
        myDictionary.Add("lili", 2);

        // Find Method test
        int geryValue;
        Console.WriteLine("Find Method test");
        Console.WriteLine("gery found = {0}, value = {1}",myDictionary.Find("gery", out geryValue), geryValue);
        Console.WriteLine();

        // Remove Method test
        Console.WriteLine("Remove Method test");
        myDictionary.Remove("gery");
        Console.WriteLine("gery found = {0}", myDictionary.Find("gery", out geryValue));
        Console.WriteLine();

        // Count poroperty test
        Console.WriteLine("Count Poroperty test = {0}", myDictionary.Count);
        Console.WriteLine();

        // this[] property tests (intexer tests)
        Console.WriteLine("intexer tests :");
        Console.WriteLine("kir4o value = {0}",myDictionary["kir4o"]);
        myDictionary["kir4o"] = 13;
        Console.WriteLine("kir4o value changed to {0}", myDictionary["kir4o"]);
        Console.WriteLine();

        // Keys property test
        Console.WriteLine("Keys property test :");
        HashSet<string> myKeys = myDictionary.Keys;

        foreach (string key in myKeys)
        {
            Console.WriteLine("Key = {0}",key);
        }
        Console.WriteLine();

        // Foreach test
        Console.WriteLine("Foreach test :");
        foreach (KeyValuePair<string, int> pair in myDictionary)
        {
            Console.WriteLine("{0} -> {1}", pair.Key, pair.Value);
        }
        Console.WriteLine();
    }

    /* Task 4: 
     * Implement the data structure "hash table" in a class HashTable<K,T>. 
     * Keep the data in array of lists of key-value pairs (LinkedList<KeyValuePair<K,T>>[]) 
     * with initial capacity of 16. When the hash table load runs over 75%, perform resizing to 2
     * times larger capacity. Implement the following methods and properties: Add(key, value), Find(key)value,
     * Remove( key), Count, Clear(), this[], Keys. Try to make the hash table to support iterating over its elements 
     * with foreach.
     */

    //Few functionalities are missing. If I have time I will add them as well. 

    static void Main(string[] args)
    {
        var hashTable = new HashTable<string, int>();

        for (int i = 0; i < 100; i++)
        {
            hashTable.Add("Entri" + i, i);
        }

        Console.WriteLine(hashTable.Count());
        Console.WriteLine(hashTable.Find("Entri50"));

        for (int i = 50; i < 100; i++)
        {
            hashTable.Remove("Entri" + i);
        }

        //Will throw an exception
        //Console.WriteLine(hashTable.Find("Entri50"));

        var keys = hashTable.Keys();

        foreach (var key in keys)
        {
            Console.WriteLine(key);
        }

        hashTable.Clear();
        Console.WriteLine(hashTable.Count());
    }

        static void Main(string[] args)
        {
            var hash = new HashTable<string, int>();

            for (int i = 0; i < 50; i++)
            {
                var name = "Pesho";
                hash.Add(name + i, i);
                Console.WriteLine("Count: " + hash.Count);
                Console.WriteLine("Length: " + hash.Length);

            }

            var result = hash.Find("Pesho4");
            Console.WriteLine(result);
            Console.WriteLine();

            Console.WriteLine("Count is " + hash.Count);
            hash.Remove("Pesho2");
            Console.WriteLine("Now count is " + hash.Count);

            Console.WriteLine("-------");

            foreach (var item in hash)
            {
                Console.WriteLine(item);
            }
        }

        public void FindNewKeyPairShouldWorkCorrectly()
        {
            var hashTable = new HashTable<string, int>();
            hashTable.Add("Ivan", 1);

            Assert.AreEqual(hashTable.Find("Ivan"), 1);
        }

        public void TestIfFindFindsTheValue()
        {
            var table = new HashTable<int, int>();

            table.Add(1, 11);
            Assert.AreEqual(11, table.Find(1));
        }

        static void Main(string[] args)
        {
            HashTable<string, string> phoneBook = new HashTable<string, string>();

            while (true)
            {
                var line = Console.ReadLine();
                if (line == "search")
                {
                    while (true)
                    {
                        line = Console.ReadLine();
                        if (line == "break")
                        {
                            break;
                        }

                        var entry = phoneBook.Find(line);
                        if (entry != null)
                        {
                            Console.WriteLine("{0} -> {1}", entry.Key, entry.Value);
                        }
                        else
                        {
                            Console.WriteLine("Contact {0} does not exist!", line);
                        }
                    }
                }
                else
                {
                    string[] phoneEntries = line.Split(new string[] { DELIMITER }, StringSplitOptions.RemoveEmptyEntries).ToArray();
                    phoneBook.Add(phoneEntries[0], phoneEntries[1]);
                }
            }
        }

        public static void Main()
        {
            var table = new HashTable<int, int>();

            table.Add(1, 11);
            table.Add(2, 12);
            table.Add(3, 13);
            table.Add(4, 14);
            table.Add(5, 15);
            table.Add(6, 16);
            table.Add(7, 17);
            table.Add(8, 18);
            //var four = table.Find(4);
            Console.WriteLine();
            Console.WriteLine(table.Count);
            table.Remove(4);
            table.Remove(4);
            Console.WriteLine();
            Console.WriteLine(table.Count);
            Console.WriteLine();
            var secondfour = table.Find(4);
            Console.WriteLine(table.Count);
            Console.WriteLine(secondfour);
            Console.WriteLine(table[1]);
            table[1] = 15;
            Console.WriteLine(table[1]);
            Console.WriteLine(string.Join(", ", table.Keys));
        }

        static void Main()
        {
            HashTable<string, string> hashTable = new HashTable<string, string>();
            hashTable.Add("1", "aa1");
            hashTable.Add("2", "22a");
            hashTable.Add("3", "wwer");
            hashTable.Add("4", "rrrr");
            hashTable.Add("5", "qqqq");
            hashTable.Add("6", "tttt");

            Console.WriteLine(hashTable.Find("2"));
            Console.WriteLine("Count: {0}", hashTable.Count);

            hashTable.Remove("1");
            Console.WriteLine("Count: {0}", hashTable.Count);
            Console.WriteLine(hashTable["3"]);

            Console.WriteLine("\nKeys: ");
            foreach (var item in hashTable.Keys)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine("\nIteration with foreach:");
            foreach (var item in hashTable)
            {
                Console.WriteLine("{0}: {1}", item.Key, item.Value);
            }

        }

        static void Main(string[] args)
        {
            var table = new HashTable<int, string>();
            table.Add(5,"Pencho");
            table.Add(1,"Mariika");
            table.Add(199,"Kircho");

            Console.WriteLine(table.Find(1));
            Console.WriteLine(string.Join(",",table.Keys));
            foreach (var val in table)
            {
                Console.WriteLine(val.Value);
            }
            table.Remove(199);
            foreach (var val in table)
            {
                Console.WriteLine(val.Value);
            }

            Console.WriteLine(table.Count);
            Console.WriteLine(table.Capacity);

            table.Add(10, "Pencho");
            table.Add(11, "Mariika");
            table.Add(12, "Kircho");
            table.Add(13, "Pencho");
            table.Add(14, "Mariika");
            table.Add(15, "Kircho");
            table.Add(16, "Pencho");
            table.Add(17, "Mariika");
            table.Add(18, "Kircho");
            table.Add(19, "Pencho");
            table.Add(20, "Mariika");
            table.Add(21, "Kircho");
            table.Add(22, "Pencho");
            table.Add(23, "Mariika");
            table.Add(24, "Kircho");
            table.Add(25, "Pencho");
            table.Add(26, "Mariika");
            table.Add(27, "Kircho");
            table.Add(28, "Pencho");
            table.Add(29, "Mariika");
            table.Add(30, "Kircho");

            Console.WriteLine(table.Find(19));
            Console.WriteLine(table.Capacity);
        }

        internal static void Main()
        {
            string decorationLine = new string('-', Console.WindowWidth);
            Console.Write(decorationLine);
            Console.WriteLine("***Presenting the functionality of the data structure 'Hash table'***");
            Console.Write(decorationLine);

            HashTable<string, int> clubsPoints = new HashTable<string, int>();

            Console.WriteLine("---Add operation---");
            clubsPoints.Add("Rabbits-O!", 15);
            clubsPoints.Add("Frogssy", 19);
            clubsPoints.Add("Puma Runners", 17);
            clubsPoints.Add("Lion Kings", 33);
            Console.WriteLine("Count = " + clubsPoints.Count);
            Console.WriteLine();

            Console.WriteLine("---Iterator functionality---");
            PrintClubsPoints(clubsPoints);
            Console.WriteLine();

            Console.WriteLine("---Remove operation---");
            bool isRemoved = clubsPoints.Remove("Frogssy");
            Console.WriteLine("Are 'Frogssy' removed: " + isRemoved);
            Console.WriteLine("Count = " + clubsPoints.Count);
            Console.WriteLine("Hash table after removal:");
            PrintClubsPoints(clubsPoints);
            Console.WriteLine();

            Console.WriteLine("---Indexer---");
            Console.WriteLine("'Lion Kings' points so far: " + clubsPoints["Lion Kings"]);
            clubsPoints["Rabbits-O!"] += 3;
            Console.WriteLine("'Rabbits-O!' points after a win: " + clubsPoints["Rabbits-O!"]);
            Console.WriteLine();

            Console.WriteLine("---Find operation---");
            Console.WriteLine("Info about 'Puma Runners'" + clubsPoints.Find("Puma Runners"));
            Console.WriteLine();

            Console.WriteLine("---ContainsKey operation---");
            Console.WriteLine("Is there a club 'Birdy'? - " + clubsPoints.ContainsKey("Birdy"));
            Console.WriteLine("Is there a club 'Rabbits-O!'? - " + clubsPoints.ContainsKey("Rabbits-O!"));
            Console.WriteLine();

            Console.WriteLine("---Keys property---");
            Console.Write("All clubs names are: ");
            Console.WriteLine(string.Join(", ", clubsPoints.Keys));
            Console.WriteLine();

            Console.WriteLine("---Values property---");
            Console.Write("All club's points are: ");
            Console.WriteLine(string.Join(", ", clubsPoints.Values));
            Console.WriteLine();

            Console.WriteLine("---Clear operation---");
            clubsPoints.Clear();
            Console.WriteLine("Elements count after clearing: " + clubsPoints.Count);
        }

        public void FindNewKeyPairShouldThrowWhenKeyNotExists()
        {
            var hashTable = new HashTable<string, int>
            {
                {"Ivan", 1}
            };

            hashTable.Find("Asen");
        }

    public static void Main()
    {
        var topCities = new HashTable<string, double>();

        // Add(key, value)
        topCities.Add("Tokyo", 36.9);
        topCities.Add("Jakarta", 12.8);
        topCities.Add("Seoul", 25.7);
        topCities.Add("Beijing", 23.7);
        topCities.Add("Shanghai", 21.7);

        // foreach
        foreach (var pair in topCities.OrderBy(p => -p.Value))
        {
            Console.WriteLine("{0, -8} -> {1}", pair.Key, pair.Value);
        }

        // Add already existing key
        try
        {
            topCities.Add("Jakarta", 0);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        
        // Keys
        Console.WriteLine("Keys: {0}", string.Join(", ", topCities.Keys));

        // Count
        Console.WriteLine("Number of key-value pairs: {0}", topCities.Count);

        // Find(key)
        topCities.PrintValue("Tokyo");
        Console.WriteLine("Jakarta -> {0}", topCities.Find("Jakarta"));

        // this[key]
        Console.WriteLine("Beijing -> {0}", topCities["Beijing"]);

        // ContainsKey(key)
        Console.WriteLine("Hash table contains 'Delhi': {0}", topCities.ContainsKey("Delhi"));

        // Remove(key)
        topCities.Remove("Seoul");
        Console.WriteLine("Remove 'Seoul'");
        Console.WriteLine("Keys: {0}", string.Join(", ", topCities.Keys));
        Console.WriteLine("Number of key-value pairs: {0}", topCities.Count);

        // Remove non-existing
        Console.WriteLine("Removing 'Sofia' -> {0}", topCities.Remove("Sofia"));

        // Clear
        topCities.Clear();
        Console.WriteLine("Clear hash table");
        Console.WriteLine("Number of key-value pairs: {0}", topCities.Count);
    }

        public void FindNonExistingEntryTest()
        {
            HashTable<string, int> studentMarks = new HashTable<string, int>();
            studentMarks.Add("Ivan", 5);
            studentMarks.Add("Pesho", 4);
            studentMarks.Add("Lili", 6);
            studentMarks.Add("Gosho", 3);

            studentMarks.Find("Marin");
        }