Use HeapSort and IEnumerator

Author: kdimolikas

Algorithms/Search/BinarySearcher.cs

@@ -1,160 +1,126 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
-
+using Algorithms.Sorting;
 
 namespace Algorithms.Search
 {
-    public static class BinarySearcher
+    public class BinarySearcher<T> : IEnumerator<T>
     {
 
+        private readonly IList<T> _collection;
+        private readonly Comparer<T> _comparer;
+
+        private int _currentItemIndex;
+        private int _leftIndex;
+        private int _rightIndex;
 
         /// <summary>
-        /// Apply Binary Search in a list.
+        /// The value of the current item
         /// </summary>
-        /// <typeparam name="T">Data type of items</typeparam>
-        /// <param name="collection">A list of items</param>
-        /// <param name="item">The item we search for</param>
-        /// <returns>If item found, its' index, -1 otherwise</returns>
-        public static int BinarySearch<T>(IList<T> collection, T item)
-        {
-            if (collection == null)
+        public T Current {
+
+            get
             {
-                throw new NullReferenceException("List is null");
+                return _collection[_currentItemIndex];
             }
 
-            IList<T> sCollection = MergeSort<T>(collection);
-            int itemIndex = sCollection.InternalBinarySearch(0, sCollection.Count - 1, item);
-            return itemIndex;
         }
 
 
+        object IEnumerator.Current => Current;
+
         /// <summary>
-        /// Apply MerseSort algorithm in a list.
+        /// Class constructor
         /// </summary>
-        /// <typeparam name="T">Data type of items</typeparam>
-        /// <param name="collection">A list of items</param>
-        /// <returns>Given list in ascending order</returns>
-        public static IList<T> MergeSort<T>(IList<T> collection)
+        /// <param name="collection">A list</param>
+        /// <param name="comparer">A comparer</param>
+        public BinarySearcher(IList<T> collection, Comparer<T> comparer)
         {
-            int mid = collection.Count / 2;
-            IList<T> leftList;
-            IList<T> rightList;
-
-            if (collection.Count < 2)
+            if (collection == null)
             {
-                return collection;
-               
+                throw new NullReferenceException("List is null");
             }
 
-            leftList = GetCopyOfList(collection, 0, mid - 1);
-            rightList = GetCopyOfList(collection, mid, collection.Count - 1);
-
-            leftList = MergeSort<T>(leftList);
-            rightList = MergeSort<T>(rightList);
-
-            return InternalMerge<T>(leftList, rightList);
+            this._collection = collection;
+            this._comparer = comparer;
+           
         }
 
-
+     
         /// <summary>
-        /// Merge two lists in ascending order.
+        /// Apply Binary Search in a list.
         /// </summary>
-        /// <typeparam name="T">Data type of items</typeparam>
-        /// <param name="leftCollection">The first list of items</param>
-        /// <param name="rightCollection">The second list of items</param>
-        /// <returns>Merged list in ascending order</returns>
-        private static IList<T> InternalMerge<T>(IList<T> leftCollection, IList<T> rightCollection)
+        /// <param name="item">The item we search for</param>
+        /// <returns>If item found, its' index, -1 otherwise</returns>
+        public int BinarySearch(T item)
         {
-            int i = 0;
-            int j = 0;
- 
-            IList<T> tmp = new List<T>();
-            Comparer<T> comparer = Comparer<T>.Default;
-
-            while (i < leftCollection.Count && j < rightCollection.Count)
-            {
-                if (comparer.Compare(leftCollection[i], rightCollection[j]) <= 0)
-                {
-                    tmp.Add(leftCollection[i++]);
-                }
-                else
-                {
-                    tmp.Add(rightCollection[j++]);
-                }
-            }
-
-            //Copy the remaining items of left list
-            while(i < leftCollection.Count)
-            {
-                tmp.Add(leftCollection[i++]);
-            }
-
-            //Copy the remaining items of right list
-            while (j < rightCollection.Count)
-            {
-                tmp.Add(rightCollection[j++]);
-            }
-
-            return tmp;
+            _currentItemIndex = -1;
+            _leftIndex = 0;
+            _rightIndex = _collection.Count - 1;
+            HeapSorter.HeapSort(_collection);
+            InternalBinarySearch(item);
+            return _currentItemIndex;
         }
 
 
         /// <summary>
         /// An implementation of binary search algorithm.
         /// </summary>
-        /// <typeparam name="T">Data type of items</typeparam>
-        /// <param name="collection">A list of items</param>
-        /// <param name="left">The far left index of the list</param>
-        /// <param name="right">The far right index of the list</param>
         /// <param name="item">The item we search for</param>
-        /// <returns>If found, the index of the item, otherwise -1</returns>
-        private static int InternalBinarySearch<T>(this IList<T> collection, int left, int right, T item)
+        /// <returns></returns>
+        private void InternalBinarySearch(T item)
         {
-            int mid = left + (right - left) / 2;
-            Comparer<T> comparer = Comparer<T>.Default;
-
-            if (left <= right)
+            bool found = false;
+           
+            while (MoveNext() && !found)
             {
-                if (comparer.Compare(item,collection[mid]) < 0)
+                if (_comparer.Compare(item, Current) < 0)
                 {
-                    return collection.InternalBinarySearch<T>(left, mid - 1, item);
+                    _rightIndex = _currentItemIndex - 1;
                 }
-                else if (comparer.Compare(item, collection[mid]) > 0)
+                else if (_comparer.Compare(item, Current) > 0)
                 {
-                    return collection.InternalBinarySearch<T>(mid + 1, right, item);
+                    _leftIndex = _currentItemIndex + 1;
                 }
                 else
                 {
-                    return mid;
+                    found = true;
                 }
             }
-            else
+            
+            if (!found)
             {
-                return -1;
+                this.Reset();
             }
 
         }
 
-
         /// <summary>
-        /// Copies a range of a list to another list
+        /// An implementation of IEnumerator's MoveNext method.
         /// </summary>
-        /// <typeparam name="T">Data type of items</typeparam>
-        /// <param name="list">A list of items</param>
-        /// <param name="left">Starting index of the range</param>
-        /// <param name="right">The last index of the range</param>
-        /// <returns>A copy of the given list within the given range</returns>
-        private static IList<T> GetCopyOfList<T>(IList<T> list, int left, int right)
+        /// <returns>true if iteration can proceed to the next item, false otherwise</returns>
+        public bool MoveNext()
         {
-            IList<T> copyList = new List<T>();
+            _currentItemIndex = this._leftIndex + (this._rightIndex - this._leftIndex) / 2;
 
-            for (int i = left; i <= right; i++)
+            if (_leftIndex <= _rightIndex)
+            {
+                return true;
+            }
+            else
             {
-                copyList.Add(list[i]);
+                return false;
             }
 
-            return copyList;
         }
+
+        
+        public void Reset(){ this._currentItemIndex = -1; }
+
+        
+        public void Dispose(){}
+
     }
 
 }