Added binarySearch algorithm in both recursive and iterative ways.

Author: skillmaker-dev

Algorithms.NET.Debug/Program.cs

@@ -7,20 +7,22 @@
 List<double> unsorted01 = new() { .8, .9, .3, .3, .1,0 };
 
 //var sortedDesc = Algorithms.NET.Sorting.MergeSort.MergeSortAlgorithm.SortDescending(unsortedAsc);
-var sortedAsc = Algorithms.NET.Sorting.BucketSort.BucketSortAlgorithm.SortAscending(unsorted01);
-var sortedDesc = Algorithms.NET.Sorting.BucketSort.BucketSortAlgorithm.SortDescending(unsorted01);
+//var sortedAsc = Algorithms.NET.Sorting.BucketSort.BucketSortAlgorithm.SortAscending(unsorted01);
+//var sortedDesc = Algorithms.NET.Sorting.BucketSort.BucketSortAlgorithm.SortDescending(unsorted01);
 //var sortedDesc = Algorithms.NET.Sorting.CountingSort.CountingSortAlgorithm.SortDescending(unsortedRand.ToArray());
+//Console.WriteLine(Algorithms.NET.Searching.LinearSearch.LinearSearchAlgorithm.Search(4, unsortedAsc));
+Console.WriteLine(Algorithms.NET.Searching.BinarySearch.BinarySearchAlgorithm.SearchRecursive(0, unsortedAsc));
+Console.WriteLine(Algorithms.NET.Searching.BinarySearch.BinarySearchAlgorithm.SearchIterative(0, unsortedAsc));
 
-
-foreach (var item in sortedDesc)
-{
-    Console.WriteLine(item);
-}
-Console.WriteLine();
-foreach (var item in sortedAsc)
-{
-    Console.WriteLine(item);
-}
+//foreach (var item in sortedDesc)
+//{
+//    Console.WriteLine(item);
+//}
+//Console.WriteLine();
+//foreach (var item in sortedAsc)
+//{
+//    Console.WriteLine(item);
+//}
 
 //List<double> _unsortedAsc = new();
 //var rand = new Random();
@@ -29,7 +31,8 @@
 //    _unsortedAsc.Add(rand.Next(1000000));
 //}
 
-var summary = BenchmarkRunner.Run<BenchmarkDemo>();
+//var sortingBenchmarkSummary = BenchmarkRunner.Run<SortingBenchmark>();
+var searchingBenchmarkSummary = BenchmarkRunner.Run<SearchingBenchmark>();
 
 
 

Algorithms.NET.Debug/BenchmarkDemo.cs Algorithms.NET.Debug/SortingBenchmark.csAlgorithms.NET.Debug/BenchmarkDemo.cs renamed to Algorithms.NET.Debug/SortingBenchmark.cs

@@ -9,43 +9,44 @@
 namespace Algorithms.NET.Debug
 {
     [MemoryDiagnoser]
-    public class BenchmarkDemo
+    public class SortingBenchmark
     {
-        private List<double> _unsorted = new();
-        private List<double> _unsorted2 = new();
+        private readonly List<double> _unsorted = new();
+        private readonly List<double> _unsorted2 = new();
 
-        public BenchmarkDemo()
+        public SortingBenchmark()
         {
             var rand = new Random();
             for (int i = 0; i < 10000; i++)
             {
-                _unsorted.Add(rand.NextDouble());
-                _unsorted2.Add(rand.Next(1000000));
+                double number = rand.NextDouble();
+                _unsorted.Add(number);
+                _unsorted2.Add(number);
             }
         }
 
-        //[Benchmark]
+        [Benchmark]
         public void BuiltInSort() =>
         _unsorted2.Sort();
 
 
-        //[Benchmark]
+        [Benchmark]
         public void BubbleSort() =>
         BubbleSortAlgorithm.SortAscending(_unsorted);
 
-        //[Benchmark]
+        [Benchmark]
         public void SelectionSort() =>
         SelectionSortAlgorithm.SortAscending(_unsorted);
 
-        //[Benchmark]
+        [Benchmark]
         public void InsertionSort() =>
         InsertionSortAlgorithm.SortAscending(_unsorted);
 
         [Benchmark]
         public void MergeSort() =>
         MergeSortAlgorithm.SortAscending(_unsorted);
 
-        //[Benchmark]
+        [Benchmark]
         public void QuickSort() =>
         QuickSortAlgorithm.SortAscending(_unsorted);
 

Algorithms.NET/Searching/BinarySearch/BinarySearchAlgorithm.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Algorithms.NET.Searching.BinarySearch
+{
+    public class BinarySearchAlgorithm
+    {
+        /// <summary>
+        /// Search an item in a list using BinarySearch algorithm, Time complexity of O(log n).
+        /// </summary>
+        /// <param name="item">Item to search for</param>
+        /// <param name="sortedList">Sorted list in which we want to search.</param>
+        /// <returns>Index of item if found, Otherwise returns -1.</returns>
+        public static int SearchRecursive(double item, List<double> sortedList)
+        {
+            return SearchRecursive(item, sortedList, 0, sortedList.Count - 1);
+        }
+
+        /// <summary>
+        /// Search an item in a list using BinarySearch algorithm in recursive approach, Time complexity of O(log n), Space complexity O(log n).
+        /// </summary>
+        /// <param name="item">Item to search for</param>
+        /// <param name="sortedList">Sorted list in which we want to search.</param>
+        /// <param name="endIndex">End index of searching.</param>
+        /// <param name="startIndex">Start index of searching.</param>
+        /// <returns>Index of item if found, Otherwise returns -1.</returns>
+        private static int SearchRecursive(double item, List<double> sortedList, int startIndex, int endIndex)
+        {
+            if (startIndex > endIndex)
+                return -1;
+
+            int middleIndex = (startIndex + endIndex) / 2;
+
+            if (sortedList[middleIndex] == item)
+                return middleIndex;
+
+            if (item > sortedList[middleIndex])
+                return SearchRecursive(item, sortedList, middleIndex + 1, endIndex);
+           
+            return SearchRecursive(item, sortedList, startIndex, middleIndex - 1);
+        }
+
+        /// <summary>
+        /// Search an item in a list using BinarySearch algorithm in iterative approach, Time complexity of O(log n), Space complexity O(1).
+        /// </summary>
+        /// <param name="item">Item to search for</param>
+        /// <param name="sortedList">Sorted list in which we want to search.</param>
+        /// <returns>Index of item if found, Otherwise returns -1.</returns>
+        public static int SearchIterative(double item, List<double> sortedList)
+        {
+            int start = 0;
+            int end = sortedList.Count - 1;
+
+            while (start <= end)
+            {
+                int middleIndex = (start + end) / 2;
+
+                if (sortedList[middleIndex] == item)
+                    return middleIndex;
+                    
+
+                if(item > sortedList[middleIndex])
+                    start = middleIndex + 1;
+
+                if (item < sortedList[middleIndex])
+                    end = middleIndex - 1;
+            }
+
+            return -1;
+        }
+     }
+}