Exponential search (#247)

* feat: add exponential search

* test: add test for exponential search

* fix : prettier fix

* fix: added parameters to iterative binary search

* fix: prettier fix #2

* fix: modified the return on binary search and related tests

search/binary_search.ts

@@ -8,25 +8,25 @@
  *
  * @param {number[]} array - sorted list of numbers
  * @param {number} target - target number to search for
- * @return {number} - index of the target number in the list, or -1 if not found
+ * @return {number} - index of the target number in the list, or null if not found
  * @see [BinarySearch](https://www.geeksforgeeks.org/binary-search/)
  * @example binarySearch([1,2,3], 2) => 1
- * @example binarySearch([4,5,6], 2) => -1
+ * @example binarySearch([4,5,6], 2) => null
  */
 
 export const binarySearchIterative = (
   array: number[],
-  target: number
-): number => {
-  if (array.length === 0) return -1
-
-  // declare pointers for the start, middle and end indices
-  let start = 0,
-    end = array.length - 1,
-    middle = (start + end) >> 1
+  target: number,
+  start: number = 0,
+  end: number = array.length - 1
+): number | null => {
+  if (array.length === 0) return null
 
   // ensure the target is within the bounds of the array
-  if (target < array[start] || target > array[end]) return -1
+  if (target < array[start] || target > array[end]) return null
+
+  // declare pointers for the middle index
+  let middle = (start + end) >> 1
 
   while (array[middle] !== target && start <= end) {
     // if the target is less than the middle value, move the end pointer to be middle -1 to narrow the search space
@@ -37,24 +37,24 @@ export const binarySearchIterative = (
     middle = (start + end) >> 1
   }
   // return the middle index if it is equal to target
-  return array[middle] === target ? middle : -1
+  return array[middle] === target ? middle : null
 }
 
 export const binarySearchRecursive = (
   array: number[],
   target: number,
   start = 0,
   end = array.length - 1
-): number => {
-  if (array.length === 0) return -1
+): number | null => {
+  if (array.length === 0) return null
 
   // ensure the target is within the bounds of the array
-  if (target < array[start] || target > array[end]) return -1
+  if (target < array[start] || target > array[end]) return null
 
   const middle = (start + end) >> 1
 
   if (array[middle] === target) return middle // target found
-  if (start > end) return -1 // target not found
+  if (start > end) return null // target not found
 
   // if the target is less than the middle value, move the end pointer to be middle -1 to narrow the search space
   // otherwise, move the start pointer to be middle + 1

search/exponential_search.ts

@@ -0,0 +1,40 @@
+import { binarySearchIterative } from './binary_search'
+
+/**
+ * @description Exponential search algorithm for a sorted array.
+ *
+ * The algorithm searches for a specific value in a sorted array by first finding a range
+ * where the value may be present and then performing a binary search within that range.
+ *
+ * Compared with binary search, exponential search can be more convenient and advantageous
+ * in cases where the element to be searched is closer to the beginning of the array,
+ * thus avoiding several comparisons that would make the search more verbose.
+ *
+ * @param {number[]} array - sorted list of numbers
+ * @param {number} x - target number to search for
+ * @return {number | null} - index of the target number in the list, or null if not found
+ * @see [ExponentialSearch](https://www.geeksforgeeks.org/exponential-search/)
+ * @example exponentialSearch([1, 2, 3, 4, 5], 3) => 2
+ * @example exponentialSearch([10, 20, 30, 40, 50], 35) => null
+ */
+
+export const exponentialSearch = (
+  array: number[],
+  x: number
+): number | null => {
+  const arrayLength = array.length
+  if (arrayLength === 0) return null
+
+  if (array[0] === x) return 0
+
+  let i = 1
+  while (i < arrayLength && array[i] <= x) {
+    i = i * 2
+  }
+
+  const start = Math.floor(i / 2)
+  const end = Math.min(i, arrayLength - 1)
+  const result = binarySearchIterative(array, x, start, end)
+
+  return result
+}

search/test/binary_search.test.ts

@@ -2,7 +2,7 @@ import { binarySearchIterative, binarySearchRecursive } from '../binary_search'
 
 describe('BinarySearch', () => {
   const testArray: number[] = [1, 2, 3, 4]
-  type FunctionsArray = { (array: number[], index: number): number }[]
+  type FunctionsArray = { (array: number[], index: number): number | null }[]
   const functions: FunctionsArray = [
     binarySearchIterative,
     binarySearchRecursive
@@ -12,14 +12,16 @@ describe('BinarySearch', () => {
     it('should be defined', () => {
       expect(func(testArray, 2)).toBeDefined()
     })
-    it('should return a number', () => {
-      expect(typeof func(testArray, 2)).toBe('number')
+    it('should return a number or null', () => {
+      expect(
+        typeof func(testArray, 2) === 'number' || func(testArray, 2) === null
+      ).toBe(true)
     })
-    it('should return -1 if the target is not found in the array', () => {
-      expect(func(testArray, 5)).toBe(-1)
+    it('should return null if the target is not found in the array', () => {
+      expect(func(testArray, 5)).toBe(null)
     })
-    it('should return -1 if there are no elements in the array', () => {
-      expect(func([], 5)).toBe(-1)
+    it('should return null if there are no elements in the array', () => {
+      expect(func([], 5)).toBe(null)
     })
     it('should return the index of the target if it is found in the array', () => {
       expect(func(testArray, 2)).toBe(1)

search/test/exponential_search.test.ts

@@ -0,0 +1,19 @@
+import { exponentialSearch } from '../exponential_search'
+
+describe('Exponential search', () => {
+  test.each([
+    [[1, 2, 3, 4, 5], 3, 2],
+    [[10, 20, 30, 40, 50], 35, null],
+    [[10, 20, 30, 40, 50], 10, 0],
+    [[10, 20, 30, 40, 50], 50, 4],
+    [[10, 20, 30, 40, 50], 60, null],
+    [[], 10, null],
+    [[1, 2, 3, 4, 5], 1, 0],
+    [[1, 2, 3, 4, 5], 5, 4]
+  ])(
+    'of %o, searching for %o, expected %i',
+    (array: number[], target: number, expected: number | null) => {
+      expect(exponentialSearch(array, target)).toBe(expected)
+    }
+  )
+})