diff --git a/divide-and-conquer/notes.md b/divide-and-conquer/notes.md
index de616969639c0a826e50d576bfda91d6232300ea..95cc7aaa36a269c8055d9d5c3401bd877b4b7add 100644
--- a/divide-and-conquer/notes.md
+++ b/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²)
 
 --------------------------------------------------------------------------------
 
@@ -69,11 +69,11 @@ Problem: Find the median of an odd-length list in average-case Θ(n) time.  Use
 
 ```
             In:  [8, 7, 6, 9, 5]
-            Out: …
+            Out: 7
                 /          \
                /            \
-    In:  […]                 In:  […]
-    Out: …                   Out: …
+    In:  [8, 7]              In:  [6, 9, 5]
+    Out: 7.5                 Out: 6
 ```
 
 *   Option A: We are missing information from the recursive calls.  Add output(s) so that they can return that information.
@@ -81,15 +81,15 @@ Problem: Find the median of an odd-length list in average-case Θ(n) time.  Use
 
 ## Design (second attempt)
 
-*   More generally, we want …, so we add an input `k`:
+*   More generally, we want to find an element that would appear at index `k` if the list were sorted, so we add an input `k`:
 
 ```
             In:  [8, 7, 6, 9, 5], k = 2
-            Out: …
+            Out: 7 (but how?)
                 /          \
                /            \
-    In:  […], k = 2          In:  […], k = 0
-    Out: …                   Out: …
+    In:  [8, 7], k = 2       In:  [6, 9, 5], k = 0
+    Out: ???                 Out: 5
 ```
 
 ## Partitioning
diff --git a/divide-and-conquer/src/features/sorting/sorting.js b/divide-and-conquer/src/features/sorting/sorting.js
index bca3d88bf5b65b3bddba99daeff360e4205312d0..346eb66be7f29b38ce61eafa722260a32e1b80db 100644
--- a/divide-and-conquer/src/features/sorting/sorting.js
+++ b/divide-and-conquer/src/features/sorting/sorting.js
@@ -1,7 +1,25 @@
 function merge(left, right) {
-  return []; // TODO: stub
+  const merged = [];
+  let i = 0;
+  let j = 0;
+  while (i < left.length || j < right.length) {
+    if (i < left.length && (j === right.length || left[i] < right[j])) {
+      merged.push(left[i]);
+      ++i;
+    } else {
+      merged.push(right[j]);
+      ++j;
+    }
+  }
+  return merged;
 }
 
 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);
 }