Merge pull request aalhour#119 from kdimolikas/search-algo

BinarySearcher Algorithm

Author: aalhour

Algorithms/Search/BinarySearcher.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Algorithms.Sorting;
+
+namespace Algorithms.Search
+{
+    public class BinarySearcher<T> : IEnumerator<T>
+    {
+        private readonly IList<T> _collection;
+        private readonly Comparer<T> _comparer;
+        private T _item;
+        private int _currentItemIndex;
+        private int _leftIndex;
+        private int _rightIndex;
+
+        /// <summary>
+        /// The value of the current item
+        /// </summary>
+        public T Current
+        {
+            get
+            {
+                return _collection[_currentItemIndex];
+            }
+        }
+
+        object IEnumerator.Current => Current;
+
+        /// <summary>
+        /// Class constructor
+        /// </summary>
+        /// <param name="collection">A list</param>
+        /// <param name="comparer">A comparer</param>
+        public BinarySearcher(IList<T> collection, Comparer<T> comparer)
+        {
+            if (collection == null)
+            {
+                throw new NullReferenceException("List is null");
+            }
+            _collection = collection;
+            _comparer = comparer;
+            HeapSorter.HeapSort(_collection);
+        }
+
+        /// <summary>
+        /// Apply Binary Search in a list.
+        /// </summary>
+        /// <param name="item">The item we search</param>
+        /// <returns>If item found, its' index, -1 otherwise</returns>
+        public int BinarySearch(T item)
+        {
+            bool notFound = true;
+
+            if (item == null)
+            {
+                throw new NullReferenceException("Item to search for is not set");
+            }
+            Reset();
+            _item = item;
+
+            while ((_leftIndex <= _rightIndex) && notFound)
+            {
+                notFound = MoveNext();
+            }
+
+            if (notFound)
+            {
+                Reset();
+            }
+            return _currentItemIndex;
+        }
+
+        /// <summary>
+        /// An implementation of IEnumerator's MoveNext method.
+        /// </summary>
+        /// <returns>true if iteration can proceed to the next item, false otherwise</returns>
+        public bool MoveNext()
+        {
+            _currentItemIndex = this._leftIndex + (this._rightIndex - this._leftIndex) / 2;
+
+            if (_comparer.Compare(_item, Current) < 0)
+            {
+                _rightIndex = _currentItemIndex - 1;
+            }
+            else if (_comparer.Compare(_item, Current) > 0)
+            {
+                _leftIndex = _currentItemIndex + 1;
+            }
+            else
+            {
+                return false;
+            }
+            return true;
+        }
+
+        public void Reset()
+        { 
+            this._currentItemIndex = -1;
+            _leftIndex = 0;
+            _rightIndex = _collection.Count - 1;
+        }
+
+        public void Dispose()
+        { 
+           //not implementing this, since there are no managed resources to release 
+        }
+    }
+}

UnitTest/AlgorithmsTests/BinarySearcherTest.cs

@@ -0,0 +1,81 @@
+using System.Collections.Generic;
+using Xunit;
+using Algorithms.Search;
+
+namespace UnitTest.AlgorithmsTests
+{
+    public static class BinarySearcherTest
+    {
+        [Fact]
+        public static void IntBinarySearchTest()
+        {
+            //list of ints
+            IList<int> list = new List<int> { 9, 3, 7, 1, 6, 10 };
+            IList<int> sortedList = new List<int> { 1, 3, 6, 7, 9, 10 };
+            int numToSearch = 6;
+            BinarySearcher<int> intSearcher = new BinarySearcher<int>(list, Comparer<int>.Default);
+            int actualIndex = intSearcher.BinarySearch(numToSearch);
+            int expectedIndex = sortedList.IndexOf(numToSearch);
+
+            Assert.Equal(expectedIndex, actualIndex);
+            Assert.Equal(numToSearch, intSearcher.Current);
+
+            numToSearch = 20;
+            int itemNotExists = intSearcher.BinarySearch(numToSearch);
+            Assert.Equal(-1, itemNotExists);
+        }
+
+        [Fact]
+        public static void StringBinarySearchTest()
+        {
+            //list of strings
+            IList<string> animals = new List<string> { "lion", "cat", "tiger", "bee", "sparrow" };
+            IList<string> sortedAnimals = new List<string> { "bee", "cat", "lion", "sparrow", "tiger" };
+            string itemToSearch = "bee";
+            BinarySearcher<string> strSearcher = new BinarySearcher<string>(animals, Comparer<string>.Default);
+            int actualIndex = strSearcher.BinarySearch(itemToSearch);
+            int expectedAnimalIndex = sortedAnimals.IndexOf(itemToSearch);
+
+            Assert.Equal(expectedAnimalIndex, actualIndex);
+            Assert.Equal(itemToSearch, strSearcher.Current);
+
+            itemToSearch = "shark";
+            int itemNotExist = strSearcher.BinarySearch(itemToSearch);
+            Assert.Equal(-1, itemNotExist);
+        }
+
+        [Fact]
+        public static void MoveNextTest()
+        {
+            IList<int> items = new List<int> {3, 5, 2, 6, 1, 4};
+            BinarySearcher<int> searcher = new BinarySearcher<int>(items, Comparer<int>.Default);
+            searcher.BinarySearch(1);
+            //reset indices to test MoveNext()
+            searcher.Reset();
+            IList<int> leftEnumeratedValues = new List<int> {3, 2, 1};
+            int i = 0;
+            while (searcher.MoveNext())
+            {
+                Assert.Equal(leftEnumeratedValues[i++], searcher.Current);
+            }
+
+            searcher.BinarySearch(6);
+            //reset indices to test MoveNext()
+            searcher.Reset();
+            IList<int> rightEnumeratedValues = new List<int> {3, 5, 6};
+            i = 0;
+            while (searcher.MoveNext())
+            {
+                Assert.Equal(rightEnumeratedValues[i++], searcher.Current);
+            }
+
+        }
+
+        [Fact]
+        public static void NullCollectionExceptionTest()
+        {
+            IList<int> list = null;
+            Assert.Throws<System.NullReferenceException>(() => new BinarySearcher<int>(list, Comparer<int>.Default));
+        }
+    }
+}