Add jump search algorithm implementation with tests and docs

Author: toramanomer

.vscode/launch.json

@@ -0,0 +1,19 @@
+{
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"type": "node",
+			"request": "launch",
+			"name": "Debug Current TS File",
+			"runtimeExecutable": "tsx",
+			"skipFiles": ["<node_internals>/**"],
+			"args": ["${file}"],
+			"cwd": "${workspaceFolder}",
+			"internalConsoleOptions": "openOnSessionStart",
+			"resolveSourceMapLocations": [
+				"${workspaceFolder}/**",
+				"!**/node_modules/**"
+			]
+		}
+	]
+}

README.md

@@ -7,6 +7,15 @@ Linear search is a searching algorithm that sequentially checks each element in
 -   **Best Case:** **O(1)** (Element found at the beginning)
 -   **Worst Case:** **O(n)** (Element at the end or not present)
 
+# Jump Search
+
+Jump Search is a searching searching algorithm that works on **sorted** arrays. It reduces the number of comparisons by jumping ahead in fixed steps instead of checking elements one by one.
+
+## Time Complexity
+
+-   **Best Case:** O(1) (First element is the target)
+-   **Worst Case:** O(sqrt{n})
+
 # Binary Search
 
 Binary search is a searching algorithm that find the desiired element in a **sorted** sequence by repeatedly dividing the search interval in half until the target is found or the interval is empty.

src/algorithms/searching/jumpSearch.ts

@@ -0,0 +1,48 @@
+export const jumpSearch = <T>(
+	sortedArray: T[],
+	target: T,
+	jumpSize?: number
+): { index: number; element: T } | null => {
+	const length = sortedArray.length
+
+	if (typeof jumpSize === 'undefined')
+		jumpSize = Math.floor(Math.sqrt(length))
+	else {
+		if (typeof jumpSize !== 'number')
+			throw new TypeError('jumpSize must be a number')
+		else if (!Number.isInteger(jumpSize))
+			throw new Error('jumpSize must be an integer')
+		else if (jumpSize <= 0)
+			throw new RangeError('jumpSize must be a positive integer')
+		else if (jumpSize >= length)
+			throw new RangeError(
+				'jumpSize must be smaller than the array length'
+			)
+	}
+
+	for (let index = 0; index < length; ) {
+		const element = sortedArray[index]
+
+		if (target === element) return { index, element }
+		if (target > element) {
+			if (index + jumpSize > length - 1) {
+				for (let j = index + 1; j < length; j++) {
+					const element = sortedArray[j]
+					if (target === sortedArray[j]) return { index: j, element }
+				}
+				return null
+			}
+			index += jumpSize
+			continue
+		}
+		if (target < element) {
+			for (let j = index; j > index - jumpSize; j--) {
+				const element = sortedArray[j]
+				if (target === sortedArray[j]) return { index: j, element }
+			}
+			return null
+		}
+	}
+
+	return null
+}

tests/algorithms/searching/jumpSearch.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest'
+import { jumpSearch } from '../../../src/algorithms/searching/jumpSearch'
+
+describe('jumpSearch', () => {
+	describe('when array is empty', () => {
+		it('should return null', () => {
+			expect(jumpSearch([], 1)).toBeNull()
+		})
+	})
+
+	describe('when using default jump size', () => {
+		describe('and the target is in the list', () => {
+			const vectors = Array.from(
+				{ length: 10 },
+				(_, index) => index + 1
+			).map((int, index) => ({
+				array: Array.from({ length: 10 }, (_, index) => index + 1),
+				target: int,
+				expected: { index, element: int }
+			}))
+
+			it('should retur the target with its index', () => {
+				vectors.forEach(({ array, target, expected }) => {
+					expect(jumpSearch(array, target)).toStrictEqual(expected)
+				})
+			})
+		})
+		describe('and the target is not in the list', () => {
+			const vectors = Array.from(
+				{ length: 10 },
+				(_, index) => index + 1
+			).map(() => ({
+				array: Array.from({ length: 10 }, (_, index) => index + 1),
+				target: 100
+			}))
+
+			it('should retur the target with its index', () => {
+				vectors.forEach(({ array, target }) => {
+					expect(jumpSearch(array, target)).toBeNull()
+				})
+			})
+		})
+	})
+})