Find max recursion

Maths/FindMaxRecursion.js

@@ -0,0 +1,43 @@
+/**
+ * @function findMaxRecursion
+ * @description This algorithm will find the maximum value of a array of numbers.
+ *
+ * @param {Integer[]} arr Array of numbers
+ * @param {Integer} left Index of the first element
+ * @param {Integer} right Index of the last element
+ *
+ * @return {Integer} Maximum value of the array
+ *
+ * @see [Maximum value](https://en.wikipedia.org/wiki/Maximum_value)
+ *
+ * @example findMaxRecursion([1, 2, 4, 5]) = 5
+ * @example findMaxRecursion([10, 40, 100, 20]) = 100
+ * @example findMaxRecursion([-1, -2, -4, -5]) = -1
+ */
+function findMaxRecursion (arr, left, right) {
+  const len = arr.length
+
+  if (len === 0 || !arr) {
+    return undefined
+  }
+
+  if (left >= len || left < -len || right >= len || right < -len) {
+    throw new Error('Index out of range')
+  }
+
+  if (left === right) {
+    return arr[left]
+  }
+
+  // x >> y == floor(x / pow(2, y))
+  const mid = (left + right) >> 1
+
+  // n >> m is equivalent to floor(n / pow(2, m)), floor(n / 2) in this case
+  const leftMax = findMaxRecursion(arr, left, mid)
+  const rightMax = findMaxRecursion(arr, mid + 1, right)
+
+  // Return the maximum
+  return Math.max(leftMax, rightMax)
+}
+
+export { findMaxRecursion }

Maths/test/FindMaxRecursion.test.js

@@ -0,0 +1,58 @@
+import { findMaxRecursion } from '../FindMaxRecursion'
+
+describe('Test findMaxRecursion function', () => {
+  const positiveAndNegativeArray = [1, 2, 4, 5, -1, -2, -4, -5]
+  const positiveAndNegativeArray1 = [10, 40, 100, 20, -10, -40, -100, -20]
+
+  const positiveArray = [1, 2, 4, 5]
+  const positiveArray1 = [10, 40, 100, 20]
+
+  const negativeArray = [-1, -2, -4, -5]
+  const negativeArray1 = [-10, -40, -100, -20]
+
+  const zeroArray = [0, 0, 0, 0]
+  const emptyArray = []
+
+  it('Testing with positive arrays', () => {
+    expect(findMaxRecursion(positiveArray, 0, positiveArray.length - 1)).toBe(5)
+    expect(findMaxRecursion(positiveArray1, 0, positiveArray1.length - 1)).toBe(
+      100
+    )
+  })
+
+  it('Testing with negative arrays', () => {
+    expect(findMaxRecursion(negativeArray, 0, negativeArray.length - 1)).toBe(
+      -1
+    )
+    expect(findMaxRecursion(negativeArray1, 0, negativeArray1.length - 1)).toBe(
+      -10
+    )
+  })
+
+  it('Testing with positive and negative arrays', () => {
+    expect(
+      findMaxRecursion(
+        positiveAndNegativeArray,
+        0,
+        positiveAndNegativeArray.length - 1
+      )
+    ).toBe(5)
+    expect(
+      findMaxRecursion(
+        positiveAndNegativeArray1,
+        0,
+        positiveAndNegativeArray1.length - 1
+      )
+    ).toBe(100)
+  })
+
+  it('Testing with zero arrays', () => {
+    expect(findMaxRecursion(zeroArray, 0, zeroArray.length - 1)).toBe(0)
+  })
+
+  it('Testing with empty arrays', () => {
+    expect(findMaxRecursion(emptyArray, 0, emptyArray.length - 1)).toBe(
+      undefined
+    )
+  })
+})