C# HashedSet.Find方法代码示例

        public static void Main()
        {
            var firstSet = new HashedSet<string>();
            var secondSet = new HashedSet<string>();

            firstSet.Add("Pesho");
            firstSet.Add("Gosho");
            firstSet.Add("Tosho");

            secondSet.Add("Ivan");
            secondSet.Add("Petkan");
            secondSet.Add("Dragan");

            Console.WriteLine(firstSet);
            Console.WriteLine(secondSet);

            Console.WriteLine(firstSet.Intersect(secondSet));
            Console.WriteLine(secondSet.Intersect(firstSet));

            Console.WriteLine(firstSet.Union(secondSet));
            Console.WriteLine(secondSet.Union(firstSet));

            firstSet.Remove("Pesho");
            firstSet.Remove("Tosho");
            Console.WriteLine(firstSet);

            Console.WriteLine(firstSet.Find("Tosho"));
            Console.WriteLine(firstSet.Find("Gosho"));

            Console.WriteLine(firstSet.Count);
        }

        static void Main()
        {
            var set = new HashedSet<int>();

            set.Add(5);
            set.Add(3);
            set.Add(-4);
            set.Add(12);
            set.Add(0);
            set.Add(-50);
            set.Add(10);
            Console.WriteLine("Set contains 12 -> {0}", set.Find(12));
            Console.WriteLine("Set contains 13 -> {0}", set.Find(13));
            set.Remove(10);
            Console.WriteLine("Removed 10\nSet contains 10 -> {0}", set.Find(10));
            Console.WriteLine("Set contains {0} items", set.Count);
            Console.WriteLine("Set 1: {0}", set);

            var anotherSet = new HashedSet<int>();
            anotherSet.Add(-4);
            anotherSet.Add(15);
            anotherSet.Add(0);
            anotherSet.Add(-122);
            anotherSet.Add(35);
            Console.WriteLine("Set 2: {0}", anotherSet);

            set.Union(anotherSet);
            Console.WriteLine("Set after union: {0}", set);

            set.Intersect(anotherSet);
            Console.WriteLine("Set after intersect: {0}", set);

            set.Clear();
            Console.WriteLine("Set contains {0} items after clear", set.Count);
        }

        public void TestFindWithInvalidKey()
        {
            var table = new HashedSet<string>();
            table.Add("Pesho");

            var value = table.Find("Peho");
        }

        public void TestFindShouldProperlyWork()
        {
            var table = new HashedSet<string>();
            table.Add("Pesho");

            Assert.AreEqual(true, table.Find("Pesho"));
        }

    public static void Main()
    {
        HashedSet<float> firstSet = new HashedSet<float>();
        firstSet.Add(1f);
        firstSet.Add(1.4f);
        firstSet.Add(1.7f);
        firstSet.Add(2f);
        firstSet.Add(2.2f);
        firstSet.Remove(1.7f);
        Console.WriteLine(firstSet.Find(1f));
        Console.WriteLine(firstSet.Count);

        HashedSet<float> secondSet = new HashedSet<float>();
        secondSet.Add(1f);
        secondSet.Add(2f);
        secondSet.Add(3f);
        secondSet.Add(5f);

        HashedSet<float> thirdSet = new HashedSet<float>();
        thirdSet.Add(1f);
        thirdSet.Add(2f);
        thirdSet.Add(3f);
        thirdSet.Add(5f);

        secondSet.Union(firstSet);
        thirdSet.Intersect(firstSet);
        firstSet.Clear();
    }

        public void FindShouldThrowIfKeyNotExists()
        {
            var set = new HashedSet<int>();

            int value = 5;
            set.Add(value);

            int actual = set.Find(value + 1);
            Assert.AreEqual(value, actual);
        }

        public void FindShouldReturnValue()
        {
            var set = new HashedSet<int>();

            int value = 5;
            set.Add(value);

            int actual = set.Find(value);
            Assert.AreEqual(value, actual);
        }

 internal static void Main()
 {
     HashedSet<int> test = new HashedSet<int>();
     HashedSet<int> other = new HashedSet<int>();
     test.Add(1);
     test.Add(2);
     test.Add(3);
     test.Add(4);
     test.Add(5);
     test.Add(6);
     other.Add(4);
     other.Add(5);
     other.Add(6);
     other.Add(7);
     other.Add(8);
     Console.WriteLine("Initial hash set:");
     Console.WriteLine(string.Join(", ", test));
     Console.WriteLine("--------------------------------------------------------------");
     Console.WriteLine("After removal of 3:");
     test.Remove(3);
     Console.WriteLine(string.Join(", ", test));
     Console.WriteLine("--------------------------------------------------------------");
     Console.WriteLine("Is 1 found? {0}", test.Find(1));
     Console.WriteLine("Is 3 found? {0}", test.Find(3));
     Console.WriteLine("--------------------------------------------------------------");
     Console.WriteLine("First hash set:");
     Console.WriteLine(string.Join(", ", test));
     Console.WriteLine("Member count: {0}", test.Count);
     Console.WriteLine("--------------------------------------------------------------");
     Console.WriteLine("Second hash set:");
     Console.WriteLine(string.Join(", ", other));
     Console.WriteLine("Member count: {0}", other.Count);
     Console.WriteLine("--------------------------------------------------------------");
     Console.WriteLine("Intersect of the first and second:");
     Console.WriteLine(string.Join(", ", test.Intersect(other)));
     Console.WriteLine("--------------------------------------------------------------");
     Console.WriteLine("Union of the first and second:");
     Console.WriteLine(string.Join(", ", test.Union(other)));
     Console.WriteLine("--------------------------------------------------------------");
     test.Clear();
     Console.WriteLine("First hash set after clear:");
     Console.WriteLine(string.Join(", ", test));
 }

        static void Main()
        {
            HashedSet<int> hSet = new HashedSet<int>();

            hSet.Add(5);
            hSet.Add(15);
            hSet.Add(5);

            Console.WriteLine(hSet.Find(45));
            Console.WriteLine(hSet.Find(15));
            hSet.Remove(5);
            Console.WriteLine(hSet.Find(5));

            hSet.Clear();

            Console.WriteLine(hSet.Count);

            hSet.Add(5);
            hSet.Add(15);
            hSet.Add(25);
            hSet.Add(35);

            HashedSet<int> hSetTwo = new HashedSet<int>();
            hSetTwo.Add(4);
            hSetTwo.Add(24);
            hSetTwo.Add(25);
            hSetTwo.Add(35);

            var newIntersectedSet = hSet.Intersect(hSetTwo);

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

            var newUnitedSet = hSet.Union(hSetTwo);

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

    /* 5 Implement the data structure "set" in a class HashedSet<T> using your class HashTable<K,T>
     * to hold the elements. Implement all standard set operations like Add(T), Find(T), Remove(T),
     * Count, Clear(), union and intersect.
     * */
    static void Main(string[] args)
    {
        var set = new HashedSet<int>();

        Debug.Assert(set.Count == 0);
        Debug.Assert(!set.Find(1));

        set.Add(1);

        Debug.Assert(set.Count == 1);
        Debug.Assert(set.Find(1));

        set.Add(2);

        Debug.Assert(set.Count == 2);
        Debug.Assert(set.Find(2));

        set.Add(1);

        Debug.Assert(set.Count == 2);
        Debug.Assert(set.Find(1));

        set.Remove(1);

        Debug.Assert(set.Count == 1);
        Debug.Assert(!set.Find(1));
        Debug.Assert(set.Find(2));

        var set1 = new HashedSet<int> { 1, 2, 3, 4, 5, 6 }.Intersect(new HashedSet<int> { 2, 4, 6, 8, 10 });
        Debug.Assert(set1.SameContents(new[] { 2, 4, 6 }, i => i));

        var set2 = new HashedSet<int> { 1, 2, 3, 4, 5, 6 }.Union(new HashedSet<int> { 2, 4, 6, 8, 10 });
        Debug.Assert(set2.SameContents(new[] { 1, 2, 3, 4, 5, 6, 8, 10 }, i => i));
    }

        static void Main(string[] args)
        {
            var set = new HashedSet<int>(new[] { 1, 2, 3, 4, 5 });
            Console.WriteLine("Set: {0}", set);

            // Add
            set.Add(6);
            Console.WriteLine("Add '6' -> {0}", set);

            // Add existing
            set.Add(6);
            Console.WriteLine("Add '6' -> {0}", set);

            // Find
            Console.WriteLine("Find '0': {0}", set.Find(0));
            Console.WriteLine("Find '6': {0}", set.Find(6));

            // Remove
            set.Remove(3);
            Console.WriteLine("Remove '3' -> {0}", set);

            // Count
            Console.WriteLine("Number of elements: {0}", set.Count);

            // Union
            var collection = new[] { 3, 7 };
            set.Union(collection);
            Console.WriteLine("Union with [{0}] -> {1}", string.Join(", ", collection), set);

            // Intersection
            collection = new[] { 5, 6, 7, 8, 9 };
            set.Intersect(collection);
            Console.WriteLine("Intersection with [{0}] -> {1}", string.Join(", ", collection), set);

            // Clear
            set.Clear();
            Console.WriteLine("Clear set...");
            Console.WriteLine("Number of elements: {0}", set.Count);
        }

        public void ShouldReturnTrueWhenTryingToFindAvailableElement()
        {
            var hashedSet = new HashedSet<string>();

            for (int i = 0; i < 10; i++)
            {
                hashedSet.Add("test" + i);
            }

            for (int i = 0; i < 10; i++)
            {
                var expectedTrue = hashedSet.Find("test" + i);

                Assert.IsTrue(expectedTrue);
            }
        }

        public void ShouldReturnFalseWhenTryingToFindUnavailableElement()
        {
            var hashedSet = new HashedSet<string>();

            for (int i = 0; i < 10; i++)
            {
                hashedSet.Add("test" + i);
            }

            for (int i = 0; i < 10; i++)
            {
                var expectedFalse = hashedSet.Find("false" + i);

                Assert.IsFalse(expectedFalse);
            }
        }

    static void Main()
    {
        HashedSet<int> hashSet1 = new HashedSet<int>();

        for (int i = 0; i < 10; i++)
        {
            hashSet1.Add(i);
        }

        Console.WriteLine("Find element with key = 4");
        Console.WriteLine(hashSet1.Find(4));

        Console.WriteLine("Find element with key = 2 and write the count of elements");
        hashSet1.Remove(2);
        Console.WriteLine(hashSet1.Count);

        HashedSet<int> hashSet2 = new HashedSet<int>();
        hashSet2.Add(5);
        hashSet2.Add(9);
        hashSet2.Add(33);

        Console.WriteLine("Union: ");
        hashSet1.UnionWith(hashSet2);
        for (int i = 0; i < hashSet1.Container.Count; i++)
        {
            Console.WriteLine(hashSet1.Container.Keys[i]);
        }
        Console.WriteLine();

        Console.WriteLine("Intersect: ");
        hashSet1.IntersectWith(hashSet2);

        for (int i = 0; i < hashSet1.Container.Count; i++)
        {
            Console.WriteLine(hashSet1.Container.Keys[i]);
        }
        Console.WriteLine();

        Console.WriteLine("count after clear");
        hashSet2.Clear();
        Console.WriteLine(hashSet2.Container.Count);
    }

        public static void Main()
        {
            // Input array that contains three duplicate strings.
            string[] arrayWithDuplicatedValues = { "cat", "dog", "cat", "leopard", "tiger", "cat" };

            // Display the array.
            Console.WriteLine("---------- Array with duplicated items ----------");
            Console.WriteLine(string.Join(",", arrayWithDuplicatedValues));

            // Use HashSet constructor to ensure unique strings.
            var hashedSet = new HashedSet<string>();
            for (int i = 0; i < arrayWithDuplicatedValues.Length; i++)
            {
                hashedSet.Add(arrayWithDuplicatedValues[i]);
            }

            // Display the resulting array.
            Console.WriteLine("\n---------- HashedSet without duplicated items ----------");
            foreach (var item in hashedSet)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine("\n---------- Test Find(cat) ----------");
            Console.WriteLine(hashedSet.Find("cat"));

            Console.WriteLine("\n---------- Test Remove(cat) and print all elements again ----------");
            hashedSet.Remove("cat");
            foreach (var item in hashedSet)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine("\n---------- Test Count() ----------");
            Console.WriteLine(hashedSet.Count());

            Console.WriteLine("\n---------- Test Clear() and print count ----------");
            hashedSet.Clear();
            Console.WriteLine(hashedSet.Count());
        }