Designed and implemented merge sort.

divide-and-conquer/notes.md

@@ -21,19 +21,19 @@ Problem: Sort a list in Θ(n log n) time.
 
 ```
             In:  [8, 7, 6, 9, 5]
-            Out: […, …, …, …, …]
+            Out: [5, 6, 7, 8, 9]
                 /          \
                /            \
-    In:  […]                 In:  […]
-    Out: […]                 Out: […]
+    In:  [8, 7]              In:  [6, 9, 5]
+    Out: [7, 8]              Out: [5, 6, 9]
        /  \                    /      \
       /    \                  /        \
-In:  […]    In:  […]    In:  […]        In:  […]
-Out: […]    Out: […]    Out: […]        Out: […]
+In:  [8]    In:  [7]    In:  [6]        In:  [9, 5]
+Out: [8]    Out: [7]    Out: [6]        Out: [5, 9]
                                            /  \
                                           /    \
-                                    In:  […]    In:  […]
-                                    Out: […]    Out: […]
+                                    In:  [9]    In:  [5]
+                                    Out: [9]    Out: [5]
 ```
 
 ## Analysis
@@ -42,14 +42,14 @@ Out: […]    Out: […]    Out: […]        Out: […]
 
     T(n) = T(⌊n/2⌋) + T(⌈n/2⌉) + Θ(n)   for n ≫ 0
     T(n) ≈ 2T(n/2) + Θ(n)               for n ≫ 0
-    T(n) = Θ(⋯)
+    T(n) = Θ(n log n)
 
 *   Uneven split:
 
     T(n) = T(n - 1) + T(1) + Θ(n)   for n ≫ 0
     T(n) = T(n - 1) + Θ(1) + Θ(n)   for n ≫ 0
     T(n) = T(n - 1) + Θ(n)          for n ≫ 0
-    T(n) = Θ(⋯)
+    T(n) = Θ(n²)
 
 --------------------------------------------------------------------------------
 

divide-and-conquer/src/features/sorting/sorting.js

 function merge(left, right) {
-  return []; // TODO: stub
+  const results = [];
+  let i = 0;
+  let j = 0;
+  while (i < left.length || j < right.length) {
+    if (j >= right.length || (i < left.length && left[i] < right[j])) {
+      results.push(left[i]);
+      ++i;
+    } else {
+      results.push(right[j]);
+      ++j;
+    }
+  }
+  return results;
 }
 
 export function sort(list) {
-  return list; // TODO: stub
+  if (list.length < 2) {
+    return list;
+  }
+  const middleIndex = Math.floor(list.length / 2);
+  const left = sort(list.slice(0, middleIndex));
+  const right = sort(list.slice(middleIndex, list.length));
+  return merge(left, right);
 }