feat: add sentinel search algorithm

Author: hasanalkaf3

Search/QuickSelectSearch.js

@@ -18,16 +18,15 @@ export function quickSelectSearch(array, k) {
 
   let from = 0
   let to = array.length - 1
+
   while (from < to) {
-    let left = from
-    let right = to
+    let [left, right] = [from, to]
+
     const pivot = array[Math.ceil((left + right) * 0.5)]
 
     while (left < right) {
       if (array[left] >= pivot) {
-        const tmp = array[left]
-        array[left] = array[right]
-        array[right] = tmp
+        ;[array[left], array[right]] = [array[right], array[left]]
         --right
       } else {
         ++left

Search/SentinelSearch.js

@@ -0,0 +1,41 @@
+/**
+ * @function sentinelSearch
+ * @description Sentinel search algorithm for array.
+ *
+ * Sentinel linear search is a variation of the standard linear search algorithm used to
+ * find a target value in an array or list. The basic idea behind this algorithm is to add a
+ * sentinel value at the end of the array which is equal to the target value we are looking for.
+ * This helps to avoid checking the array boundary condition during each iteration of the loop,
+ * as the sentinel value acts as a stopper for the loop.
+ *
+ * @param {number[]} array - sorted list of numbers
+ * @param {number} target - target number to search for
+ * @return {number | null} - index of the target number in the list, or null if not found
+ * @see [SentinelSearch](https://www.geeksforgeeks.org/sentinel-linear-search/)
+ * @example sentinelSearch([1,2,3], 2) => 1
+ * @example sentinelSearch([4,5,6], 2) => null
+ * @complexity_analysis
+ * Time Complexity :
+ * Worst Case -> The time complexity of the Sentinel Linear Search algorithm is O(n) in the worst case.
+ * Best Case -> In the best case, when the key is found in the first iteration, the time complexity will be O(1).
+ * Average Case -> However, the average time complexity is still O(n).
+ * Auxiliary Space: O(1)
+ */
+
+export const sentinelSearch = (array, target) => {
+  const arrayLength = array.length
+  if (arrayLength === 0) return null
+
+  // Element to be searched is placed at the last index
+  const last = array[arrayLength - 1]
+  array[arrayLength - 1] = target
+
+  let index = 0
+  while (array[index] !== target) index++
+
+  // Put the last element back
+  array[arrayLength - 1] = last
+
+  if (index < arrayLength - 1 || array[arrayLength - 1] === target) return index
+  return null
+}

Search/test/SentinelSearch.test.js

@@ -0,0 +1,13 @@
+import { sentinelSearch } from '../SentinelSearch'
+
+describe('Sentinel search', () => {
+  test.each([
+    [['o', 'b', 'c'], 'c', 2],
+    [[1, 2, 3, 4, 5], 4, 3],
+    [['s', 't', 'r', 'i', 'n', 'g'], 'a', null],
+    [['1', '2', '3'], '1', 0],
+    [['4', 'e', '6', '10'], 4, null]
+  ])('of %o , searching for %o, expected %i', (array, target, index) => {
+    expect(sentinelSearch(array, target)).toStrictEqual(index)
+  })
+})