Add exponential search algorithm implementation with tests and update README

Author: toramanomer

README.md

@@ -3,6 +3,8 @@
 1. [Linear Search](#linear-search)
 2. [Jump Search](#jump-search)
 3. [Binary Search](#binary-search)
+4. [Interpolation Search](#interpolation-search)
+5. [Exponential Search](#exponential-search)
 
 # Searching Slgorithms
 
@@ -41,3 +43,12 @@ Interpolation search is a searching algorithm that is used to search for a targe
 
 -   **Best Case:** **O(1)** (Target found on first guess)
 -   **Worst Case:** **O(log log n)** (Assuming uniform distribution)
+
+## Exponential Search
+
+Exponential search is a searching algorithm used to find the position of a target element in a **sorted array** by progressively doubling the size of the search range until the target is within that range. Once the range is found, Binary Search is applied to find the exact index of the target.
+
+### Time Complexity
+
+-   **Best Case:** **O(log n)**
+-   **Worst Case:** **O(log n)**

src/algorithms/searching/exponentialSearch.ts

@@ -0,0 +1,23 @@
+export const exponentialSearch = (
+	sortedArray: number[],
+	target: number
+): number => {
+	const length = sortedArray.length
+	if (length === 0) return -1
+
+	let index = 1
+
+	while (index < length && sortedArray[index] < target) index = index * 2
+
+	let leftIndex = index / 2
+	let rightIndex = index
+	while (leftIndex <= rightIndex) {
+		const midIndex = Math.floor((leftIndex + rightIndex) / 2)
+		const midElement = sortedArray[midIndex]
+		if (target === midElement) return midIndex
+		if (target > midElement) leftIndex = midIndex + 1
+		else rightIndex = midIndex - 1
+	}
+
+	return -1
+}

tests/algorithms/searching/exponentialSearch.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest'
+import { exponentialSearch } from '../../../src/algorithms/searching/exponentialSearch'
+
+describe('interpolationSearch', () => {
+	describe('when array is empty', () => {
+		it('should return null', () => {
+			expect(exponentialSearch([], 1)).toBe(-1)
+		})
+	})
+
+	describe('when array is not empty', () => {
+		it('should return the correct index', () => {
+			const vectors = Array.from(
+				{ length: 10 },
+				(_, index) => index + 1
+			).map((positiveInt, index) => ({
+				array: Array.from({ length: 10 }, (_, index) => index + 1),
+				target: positiveInt,
+				expected: index
+			}))
+
+			vectors.forEach(({ array, target, expected }) => {
+				expect(exponentialSearch(array, target)).toBe(expected)
+			})
+		})
+	})
+})