Initial data commit

Task/Sorting-algorithms-Merge-sort/JavaScript/sorting-algorithms-merge-sort-1.js

@@ -0,0 +1,75 @@
+function mergeSort(v) {
+    if (v.length <= 1) {
+        return v;
+    }
+
+    let m = Math.floor(v.length / 2);
+    let l = mergeSort(v.slice(0, m));
+    let r = mergeSort(v.slice(m));
+    return merge(l, r);
+
+    function merge(a, b) {
+        let i = 0, j = 0;
+        let n = a.length + b.length;
+        let c = [];
+        while (c.length < n) {
+            if (i < a.length && (j >= b.length || a[i] < b[j])) {
+                c.push(a[i++]);
+            } else {
+                c.push(b[j++]);
+            }
+        }
+        return c;
+    }
+}
+
+function mergeSortInPlace(v) {
+    if (v.length <= 1) {
+        return;
+    }
+
+    let m = Math.floor(v.length / 2);
+    let l = v.slice(0, m);
+    let r = v.slice(m);
+    mergeSortInPlace(l);
+    mergeSortInPlace(r);
+    merge(l, r, v);
+
+    // merge a + b -> c
+    function merge(a, b, c) {
+        let i = 0, j = 0;
+        for (let k = 0; k < c.length; k++) {
+            if (i < a.length && (j >= b.length || a[i] < b[j])) {
+                c[k] = a[i++];
+            } else {
+                c[k] = b[j++];
+            }
+        }
+    }
+}
+
+// even faster
+function mergeSortInPlaceFast(v) {
+    sort(v, 0, v.length, v.slice());
+
+    function sort(v, lo, hi, t) {
+        let n = hi - lo;
+        if (n <= 1) {
+            return;
+        }
+        let mid = lo + Math.floor(n / 2);
+        sort(v, lo, mid, t);
+        sort(v, mid, hi, t);
+        for (let i = lo; i < hi; i++) {
+            t[i] = v[i];
+        }
+        let i = lo, j = mid;
+        for (let k = lo; k < hi; k++) {
+            if (i < mid && (j >= hi || t[i] < t[j])) {
+                v[k] = t[i++];
+            } else {
+                v[k] = t[j++];
+            }
+        }
+    }
+}

Task/Sorting-algorithms-Merge-sort/JavaScript/sorting-algorithms-merge-sort-2.js

@@ -0,0 +1,46 @@
+function merge(left, right, arr) {
+  var a = 0;
+
+  while (left.length && right.length) {
+    arr[a++] = (right[0] < left[0]) ? right.shift() : left.shift();
+  }
+  while (left.length) {
+    arr[a++] = left.shift();
+  }
+  while (right.length) {
+    arr[a++] = right.shift();
+  }
+}
+
+function mergeSort(arr) {
+  var len = arr.length;
+
+  if (len === 1) { return; }
+
+  var mid = Math.floor(len / 2),
+      left = arr.slice(0, mid),
+      right = arr.slice(mid);
+
+  mergeSort(left);
+  mergeSort(right);
+  merge(left, right, arr);
+}
+
+var arr = [1, 5, 2, 7, 3, 9, 4, 6, 8];
+mergeSort(arr); // arr will now: 1, 2, 3, 4, 5, 6, 7, 8, 9
+
+// here is improved faster version, also often faster than QuickSort!
+
+function mergeSort2(a) {
+  if (a.length <= 1) return
+  const mid = Math.floor(a.length / 2), left = a.slice(0, mid), right = a.slice(mid)
+  mergeSort2(left)
+  mergeSort2(right)
+  let ia = 0, il = 0, ir = 0
+  while (il < left.length && ir < right.length)
+    a[ia++] = left[il] < right[ir] ? left[il++] : right[ir++]
+  while (il < left.length)
+    a[ia++] = left[il++]
+  while (ir < right.length)
+    a[ia++] = right[ir++]
+}