Refine tests for mergeSort

utilities/javascript/deepEqual.js

@@ -0,0 +1,38 @@
+function deepEqual(val1, val2) {
+    if (typeof val1 !== typeof val2) {
+        return false;
+    }
+
+    // Array comparison.
+    if (Array.isArray(val1) && Array.isArray(val2)) {
+        if (val1.length !== val2.length) {
+            return false;
+        }
+        for (let i = 0; i < val1.length; i++) {
+            if (!deepEqual(val1[i], val2[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // Object comparison.
+    if (typeof val1 === 'object' && typeof val2 === 'object') {
+        const keys1 = Object.keys(val1);
+        const keys2 = Object.keys(val2);
+        if (keys1.length !== keys2.length) {
+            return false;
+        }
+        for (let i = 0; i < keys1.length; i++) {
+            if (!deepEqual(val1[keys1[i]], val2[keys2[i]])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // Primitive comparison.
+    return val1 === val2;
+}
+
+module.exports = deepEqual;

utilities/javascript/mergeSort.js

@@ -1,54 +1,64 @@
 function mergeSort(arr) {
-  if (arr.length < 2) {
-    // Arrays of length 0 or 1 are sorted by definition
-    return arr;
-  }
+    if (arr.length < 2) {
+        // Arrays of length 0 or 1 are sorted by definition.
+        return arr;
+    }
 
-  const left = arr.slice(0, Math.floor(arr.length / 2));
-  const right = arr.slice(Math.floor(arr.length / 2), Math.floor(arr.length));
+    const left = arr.slice(0, Math.floor(arr.length / 2));
+    const right = arr.slice(Math.floor(arr.length / 2), Math.floor(arr.length));
 
-  return merge(mergeSort(left), mergeSort(right));
+    return merge(mergeSort(left), mergeSort(right));
 }
 
 function merge(arr1, arr2) {
-  const merged = [];
-
-  let i = 0;
-  let j = 0;
+    const merged = [];
+    let i = 0, j = 0;
 
-  while (i < arr1.length && j < arr2.length) {
-    if (arr1[i] < arr2[j]) {
-      merged.push(arr1[i]);
-      i++;
-    } else if (arr2[j] < arr1[i]) {
-      merged.push(arr2[j]);
-      j++;
-    } else {
-      merged.push(arr1[i]);
-      i++;
-      j++;
+    while (i < arr1.length && j < arr2.length) {
+        if (arr1[i] <= arr2[j]) {
+            merged.push(arr1[i]);
+            i++;
+        } else if (arr2[j] < arr1[i]) {
+            merged.push(arr2[j]);
+            j++;
+        }
     }
-  }
-
-  while (i < arr1.length) {
-    merged.push(arr1[i]);
-    i++;
-  }
-
-  while (j < arr2.length) {
-    merged.push(arr2[j]);
-    j++;
-  }
 
-  return merged;
+    merged.push(...arr1.slice(i), ...arr2.slice(j));
+    return merged;
 }
 
-const arr1 = [7, 2, 4, 3, 1, 2];
-const arr2 = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
-const arr3 = [98322, 3242, 876, -234, 34, 12331];
-const arr4 = [1, 2, 3, 4, 5, 0];
+const deepEqual = require('./deepEqual');
 
-console.log(mergeSort(arr1));
-console.log(mergeSort(arr2));
-console.log(mergeSort(arr3));
-console.log(mergeSort(arr4));
+console.log(deepEqual(
+    mergeSort([]),
+    [],
+));
+console.log(deepEqual(
+    mergeSort([1]),
+    [1],
+));
+console.log(deepEqual(
+    mergeSort([2, 1]),
+    [1, 2],
+));
+console.log(deepEqual(
+    mergeSort([7, 2, 4, 3, 1, 2]),
+    [1, 2, 2, 3, 4, 7],
+));
+console.log(deepEqual(
+    mergeSort([7, 2, 4, 3, 1, 2]),
+    [1, 2, 2, 3, 4, 7],
+));
+console.log(deepEqual(
+    mergeSort([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]),
+    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+));
+console.log(deepEqual(
+    mergeSort([98322, 3242, 876, -234, 34, 12331]),
+    [-234, 34, 876, 3242, 12331, 98322],
+));
+console.log(deepEqual(
+    mergeSort([1, 2, 3, 4, 5, 0]),
+    [0, 1, 2, 3, 4, 5],
+));