C# SortableCollection.LinearSearch方法代码示例

        public void MethodShouldReturnFalseWhenItemDoesnotExists()
        {
            var collection = new SortableCollection<int>(new[] { 52, 111, 33, 33, 46, 1125, 1 });

            Assert.IsFalse(collection.LinearSearch(1111));
            Assert.IsFalse(collection.LinearSearch(-52));
            Assert.IsFalse(collection.LinearSearch(0));
        }

 public void TesLinearSearchtWithEmptyCollection()
 {
     SortableCollection<int> collection = new SortableCollection<int>();
     bool result = collection.LinearSearch(15);
     Assert.IsFalse(result);
     result = collection.LinearSearch(0);
     Assert.IsFalse(result);
     result = collection.LinearSearch(-1);
     Assert.IsFalse(result);
 }

        internal static void Main(string[] args)
        {
            var collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });
            Console.WriteLine("All items before sorting:");
            collection.PrintAllItemsOnConsole();
            Console.WriteLine();

            collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });
            Console.WriteLine("SelectionSorter result:");
            collection.Sort(new SelectionSorter<int>());
            collection.PrintAllItemsOnConsole();
            Console.WriteLine();

            collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });
            Console.WriteLine("BubbleSorter result:");
            collection.Sort(new BubbleSorter<int>());
            collection.PrintAllItemsOnConsole();
            Console.WriteLine();

            collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });
            Console.WriteLine("InsertionSorter result:");
            collection.Sort(new InsertionSorter<int>());
            collection.PrintAllItemsOnConsole();
            Console.WriteLine();

            collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });
            Console.WriteLine("Quicksorter result:");
            collection.Sort(new QuickSorter<int>());
            collection.PrintAllItemsOnConsole();
            Console.WriteLine();

            collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });
            Console.WriteLine("MergeSorter result:");
            collection.Sort(new MergeSorter<int>());
            collection.PrintAllItemsOnConsole();
            Console.WriteLine();

            Console.WriteLine("Linear search 101:");
            Console.WriteLine(collection.LinearSearch(101));
            Console.WriteLine();

            Console.WriteLine("Binary search 101:");
            Console.WriteLine(collection.LinearSearch(101));
            Console.WriteLine();

            Console.WriteLine("Shuffle:");
            collection.Shuffle();
            collection.PrintAllItemsOnConsole();
            Console.WriteLine();

            Console.WriteLine("Shuffle again:");
            collection.Shuffle();
            collection.PrintAllItemsOnConsole();
        }

 public void TestForSingleItem()
 {
     SortableCollection<string> collection = new SortableCollection<string>(
         new List<string>() { "1" });
     Assert.IsTrue(collection.LinearSearch("1"), "Linear search failed on single item collection");
     Assert.IsTrue(collection.BinarySearch("1"), "Binary search failed on single item collection");
     Assert.IsFalse(collection.LinearSearch("2"),
         "Linear search failed on single item collection - non-existing item");
     Assert.IsFalse(collection.BinarySearch("2"),
         "Binary search failed on single item collection - non-existing item");
 }

        public void TesLinearSearchtWithOneMissingElement()
        {
            SortableCollection<int> collection = new SortableCollection<int>(
                new int[] { 3 });

            bool result = collection.LinearSearch(15);
            Assert.IsFalse(result);
            result = collection.LinearSearch(0);
            Assert.IsFalse(result);
            result = collection.LinearSearch(-1);
            Assert.IsFalse(result);
        }

 public void TestForOddItems()
 {
     SortableCollection<string> collection = new SortableCollection<string>(
         new List<string>() { "5", "1", "4", "1", "6" });
     Assert.IsTrue(collection.LinearSearch("1"), "Linear search failed on odd items collection");
     collection.Sort(new SelectionSorter<string>());
     Assert.IsTrue(collection.BinarySearch("1"), "Binary search failed on odd items collection");
     Assert.IsFalse(collection.LinearSearch("2"),
         "Linear search failed on odd items collection - non-existing item");
     Assert.IsFalse(collection.BinarySearch("2"),
         "Binary search failed on odd items collection - non-existing item");
 }

        public static void Main()
        {
            List<int> numbers = new List<int>() { 1,3,5,6,7,3,32,3,5,67,7,4,34,3};

            SortableCollection<int> collection = new SortableCollection<int>(numbers);
            Console.WriteLine(collection.LinearSearch(7));
        }

    static void Main()
    {
        var collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });
        Console.WriteLine("All items before sorting:");
        Console.WriteLine(collection);

        Console.WriteLine("SelectionSorter result:");
        collection.Sort(new SelectionSorter<int>());
        Console.WriteLine(collection);

        Console.WriteLine("Quicksorter result:");
        collection.Sort(new Quicksorter<int>());
        Console.WriteLine(collection);

        Console.WriteLine("MergeSorter result:");
        collection.Sort(new MergeSorter<int>());
        Console.WriteLine(collection);

        Console.WriteLine("Linear search 101:");
        Console.WriteLine(collection.LinearSearch(101));

        Console.WriteLine("Binary search 101:");
        Console.WriteLine(collection.BinarySearch(101));

        Console.WriteLine("Shuffle:");
        collection.Shuffle();
        Console.WriteLine(collection);

        Console.WriteLine("Shuffle again:");
        collection.Shuffle();
        Console.WriteLine(collection);
    }

        public void TestLinearSearchWithExistingElementInMiddlePositionOddCountOfElements()
        {
            var collection = new SortableCollection<int>(new[] { 49, 101, 33, 22, 11, 0, 17 });
            var result = collection.LinearSearch(22);

            Assert.IsTrue(result, "Element not found");
        }

        public void TestLinearSearchWithExistingRepeatingElementInCollection()
        {
            var collection = new SortableCollection<int>(new[] { 101, 101, 33, 22, 11, 0 });
            var result = collection.LinearSearch(101);

            Assert.IsTrue(result, "Element not found");
        }

        public void TestLinearSearchWithEmptyCollection()
        {
            var collection = new SortableCollection<int>();
            var result = collection.LinearSearch(101);

            Assert.IsFalse(result, "Element found in empty collection");
        }

        public void TestLinearSearchWithExistingElementInFirstPositionEvenCountOfElements()
        {
            var collection = new SortableCollection<int>(new[] { 49, 101, 33, 22, 11, 0 });
            var result = collection.LinearSearch(49);

            Assert.IsTrue(result, "Element not found");
        }

        public void TestBinarySearch_WithNonExistingItem()
        {
            var collection = new SortableCollection<int>(new[] { 22, 11, 101, 33, 0, 101 });

            var result = collection.LinearSearch(-11);
            Assert.AreNotEqual(true, result);
        }

        public void TestLinearSearchWithCollectionOfEqualElements()
        {
            var collection = new SortableCollection<int>(new[] { 101, 101, 101, 101, 101 });
            var result = collection.LinearSearch(101);

            Assert.IsTrue(result, "Element not found");
        }

        public void TestWithMultipleItemsNotFound()
        {
            SortableCollection<int> collection = new SortableCollection<int>(new int[] { 4, 11, -3, 7, 9, 23 });

            bool isFound = collection.LinearSearch(235);
            Assert.IsFalse(isFound);
        }