Update sorting.md

Author: djeada

notes/sorting.md

@@ -16,61 +16,59 @@ Stability, in the context of sorting, refers to preserving the relative order of
 - In an **unstable** sorting algorithm, their order might be reversed in the sorted output.
 - In a **stable** sorting algorithm, their relative order remains unchanged.
 
-Sure, let's use an example with characters and their indices to illustrate both stable and unstable sorting.
-
 #### Example
 
-Consider the following pairs of characters and their indices:
+Picture each element as a **programming-language name** followed by the 0-based position it held in the original (unsorted) list:
 
 ```
-[A0] [C1] [B2] [A3] [B4]
+[C#0] [Python1] [C#2] [JavaScript3] [Python4]
 ```
 
 #### Stable Sort
 
-When we sort these pairs alphabetically by character using a stable sorting method, pairs with the same character retain their original order in terms of indices.
+A **stable** sort keeps items that compare as “equal” in the same left-to-right order they started with.
 
-I. Sort the character 'A':
+I. Bring every `"C#"` to the front **without** changing their internal order (`0` still precedes `2`):
 
 ```
-[A0] [A3] [C1] [B2] [B4]
+[C#0] [C#2] [Python1] [JavaScript3] [Python4]
 ```
 
-II. Next, sort the character 'B', retaining the original order of indices:
+II. Next, move the two `"Python"` entries ahead of `"JavaScript"`, again preserving `1` before `4`:
 
 ```
-[A0] [A3] [B2] [B4] [C1]
+[C#0] [C#2] [JavaScript3] [Python1] [Python4]
 ```
 
-So, the stable sorted sequence is:
+So the stable-sorted sequence is:
 
 ```
-[A0] [A3] [B2] [B4] [C1]
+[C#0] [C#2] [JavaScript3] [Python1] [Python4]
 ```
 
 #### Unstable Sort
 
-When we sort these pairs alphabetically by character using an unstable sorting method, pairs with the same character may not retain their original order in terms of indices.
+An **unstable** sort does *not* guarantee that equal items keep their original relative order.
 
-I. Sort the character 'A':
+I. While collecting `"C#"` items, the algorithm might emit index `2` *before* index `0`:
 
 ```
-[A3] [A0] [C1] [B2] [B4]
+[C#2] [C#0] [Python1] [JavaScript3] [Python4]
 ```
 
-II. Next, sort the character 'B', without retaining the original order of indices:
+II. Later, the two `"Python"` entries can also swap positions (`4` before `1`):
 
 ```
-[A3] [A0] [B4] [B2] [C1]
+[C#2] [C#0] [JavaScript3] [Python4] [Python1]
 ```
 
-So, the unstable sorted sequence is:
+So one possible unstable-sorted sequence is:
 
 ```
-[A3] [A0] [B4] [B2] [C1]
+[C#2] [C#0] [JavaScript3] [Python4] [Python1]
 ```
 
-This characteristic is particularly valuable in scenarios where we might perform multiple rounds of sorting based on different criteria.
+This stability property matters when you chain sorts on multiple keys—for instance, first sorting bug reports by **severity**, then by **timestamp**—because each later pass can rely on ties already being in the correct internal order.
 
 ### Bubble Sort
 
@@ -88,6 +86,26 @@ Imagine a sequence of numbers. Starting from the beginning of the sequence, we c
 4. After the first pass, the largest item will be at the last position. On the next pass, you can ignore the last item and consider the rest of the array.
 5. Continue this process for `n-1` passes to ensure the array is completely sorted.
 
+```
+Start:  [ 5 ][ 1 ][ 4 ][ 2 ][ 8 ]
+
+Pass 1:
+  [ 5 ][ 1 ][ 4 ][ 2 ][ 8 ]  → swap(5,1) →  [ 1 ][ 5 ][ 4 ][ 2 ][ 8 ]
+  [ 1 ][ 5 ][ 4 ][ 2 ][ 8 ]  → swap(5,4) →  [ 1 ][ 4 ][ 5 ][ 2 ][ 8 ]
+  [ 1 ][ 4 ][ 5 ][ 2 ][ 8 ]  → swap(5,2) →  [ 1 ][ 4 ][ 2 ][ 5 ][ 8 ]
+  [ 1 ][ 4 ][ 2 ][ 5 ][ 8 ]  →      no swap      → [ 1 ][ 4 ][ 2 ][ 5 ][ 8 ]
+
+Pass 2:
+  [ 1 ][ 4 ][ 2 ][ 5 ] [8]  →      no swap      → [ 1 ][ 4 ][ 2 ][ 5 ] [8]
+  [ 1 ][ 4 ][ 2 ][ 5 ] [8]  → swap(4,2) →  [ 1 ][ 2 ][ 4 ][ 5 ] [8]
+  [ 1 ][ 2 ][ 4 ][ 5 ] [8]  →      no swap      → [ 1 ][ 2 ][ 4 ][ 5 ] [8]
+
+Pass 3:
+  [ 1 ][ 2 ][ 4 ] [5,8]  → all comparisons OK
+
+Result: [ 1 ][ 2 ][ 4 ][ 5 ][ 8 ]
+```
+
 #### Optimizations
 
 An important optimization for bubble sort is to keep track of whether any swaps were made during a pass. If a pass completes without any swaps, it means the array is already sorted, and there's no need to continue further iterations.
@@ -98,9 +116,9 @@ Bubble sort is stable. This means that two objects with equal keys will retain t
 
 #### Time Complexity
 
-- In the **worst-case** scenario, the time complexity of bubble sort is **$O(n^2)$**, which occurs when the array is in reverse order.
-- The **average-case** time complexity is also **$O(n^2)$**, as bubble sort generally requires quadratic time for typical unsorted arrays.
-- In the **best-case** scenario, the time complexity is **$O(n)$**, which happens when the array is already sorted, especially if an optimization like early exit is implemented.
+- In the **worst-case** scenario, the time complexity of bubble sort is $O(n^2)$, which occurs when the array is in reverse order.
+- The **average-case** time complexity is also $O(n^2)$, as bubble sort generally requires quadratic time for typical unsorted arrays.
+- In the **best-case** scenario, the time complexity is $O(n)$, which happens when the array is already sorted, especially if an optimization like early exit is implemented.
 
 #### Space Complexity
 
@@ -122,15 +140,38 @@ Consider an array of numbers. The algorithm divides the array into two parts: a
 4. Move the boundary of the sorted and unsorted subarrays one element to the right.
 5. Repeat steps 1-4 until the entire array is sorted.
 
+```
+Start:
+[ 64 ][ 25 ][ 12 ][ 22 ][ 11 ]
+
+Pass 1: find min(64,25,12,22,11)=11, swap with first element
+[ 11 ][ 25 ][ 12 ][ 22 ][ 64 ]
+
+Pass 2: find min(25,12,22,64)=12, swap with second element
+[ 11 ][ 12 ][ 25 ][ 22 ][ 64 ]
+
+Pass 3: find min(25,22,64)=22, swap with third element
+[ 11 ][ 12 ][ 22 ][ 25 ][ 64 ]
+
+Pass 4: find min(25,64)=25, swap with fourth element (self-swap)
+[ 11 ][ 12 ][ 22 ][ 25 ][ 64 ]
+
+Pass 5: only one element remains, already in place
+[ 11 ][ 12 ][ 22 ][ 25 ][ 64 ]
+
+Result:
+[ 11 ][ 12 ][ 22 ][ 25 ][ 64 ]
+```
+
 #### Stability
 
 Selection sort is inherently unstable. When two elements have equal keys, their relative order might change post-sorting. This can be problematic in scenarios where stability is crucial.
 
 #### Time Complexity
 
-- In the **worst-case**, the time complexity is **$O(n^2)$**, as even if the array is already sorted, the algorithm still iterates through every element to find the smallest.
-- The **average-case** time complexity is also **$O(n^2)$**, since the algorithm's performance generally remains quadratic regardless of input arrangement.
-- In the **best-case**, the time complexity is still **$O(n^2)$**, unlike other algorithms, because selection sort always performs the same number of comparisons, regardless of the input's initial order.
+- In the **worst-case**, the time complexity is $O(n^2)$, as even if the array is already sorted, the algorithm still iterates through every element to find the smallest.
+- The **average-case** time complexity is also $O(n^2)$, since the algorithm's performance generally remains quadratic regardless of input arrangement.
+- In the **best-case**, the time complexity is still $O(n^2)$, unlike other algorithms, because selection sort always performs the same number of comparisons, regardless of the input's initial order.
 
 #### Space Complexity
 
@@ -157,15 +198,35 @@ Imagine you have a series of numbers. The algorithm begins with the second eleme
 4. Insert the current element into the correct position so that the elements before are all smaller.
 5. Repeat steps 2-4 for each element in the array.
 
+```
+Start:
+[ 12 ][ 11 ][ 13 ][  5 ][  6 ]
+
+Pass 1: key = 11, insert into [12]
+[ 11 ][ 12 ][ 13 ][  5 ][  6 ]
+
+Pass 2: key = 13, stays in place
+[ 11 ][ 12 ][ 13 ][  5 ][  6 ]
+
+Pass 3: key =  5, insert into [11,12,13]
+[  5 ][ 11 ][ 12 ][ 13 ][  6 ]
+
+Pass 4: key =  6, insert into [5,11,12,13]
+[  5 ][  6 ][ 11 ][ 12 ][ 13 ]
+
+Result:
+[  5 ][  6 ][ 11 ][ 12 ][ 13 ]
+```
+
 #### Stability
 
 Insertion sort is stable. When two elements have equal keys, their relative order remains unchanged post-sorting. This stability is preserved since the algorithm only swaps elements if they are out of order, ensuring that equal elements never overtake each other.
 
 #### Time Complexity
 
-- In the **worst-case**, the time complexity is **$O(n^2)$**, which happens when the array is in reverse order, requiring every element to be compared with every other element.
-- The **average-case** time complexity is **$O(n^2)$**, as elements generally need to be compared with others, leading to quadratic performance.
-- In the **best-case**, the time complexity is **$O(n)$**, occurring when the array is already sorted, allowing the algorithm to simply pass through the array once without making any swaps.
+- In the **worst-case**, the time complexity is $O(n^2)$, which happens when the array is in reverse order, requiring every element to be compared with every other element.
+- The **average-case** time complexity is $O(n^2)$, as elements generally need to be compared with others, leading to quadratic performance.
+- In the **best-case**, the time complexity is $O(n)$, occurring when the array is already sorted, allowing the algorithm to simply pass through the array once without making any swaps.
 
 #### Space Complexity
 
@@ -193,15 +254,52 @@ Quick Sort, often simply referred to as "quicksort", is a divide-and-conquer alg
 3. Recursively apply steps 1 and 2 to the left and right partitions.
 4. Repeat until base case: the partition has only one or zero elements.
 
+
+```
+Start:
+[ 10 ][ 7 ][ 8 ][ 9 ][ 1 ][ 5 ]
+
+Partition around pivot = 5:
+  • Compare and swap ↓
+    [  1 ][ 7 ][ 8 ][ 9 ][ 10 ][ 5 ]
+  • Place pivot in correct spot ↓
+    [  1 ][ 5 ][ 8 ][ 9 ][ 10 ][ 7 ]
+
+Recurse on left [1]  → already sorted  
+Recurse on right [8, 9, 10, 7]:
+
+  Partition around pivot = 7:
+    [  7 ][ 9 ][ 10 ][ 8 ]
+  Recurse left []       → []
+  Recurse right [9, 10, 8]:
+
+    Partition around pivot = 8:
+      [  8 ][ 10 ][ 9 ]
+    Recurse left []     → []
+    Recurse right [10, 9]:
+      Partition pivot = 9:
+        [  9 ][ 10 ]
+      → both sides sorted
+
+    → merge [8] + [9, 10] → [  8 ][  9 ][ 10 ]
+
+  → merge [7] + [8, 9, 10] → [  7 ][  8 ][  9 ][ 10 ]
+
+→ merge [1, 5] + [7, 8, 9, 10] → [  1 ][  5 ][  7 ][  8 ][  9 ][ 10 ]
+
+Result:
+[  1 ][  5 ][  7 ][  8 ][  9 ][ 10 ]
+```
+
 #### Stability
 
 Quick sort is inherently unstable due to the long-distance exchanges of values. However, with specific modifications, it can be made stable, although this is not commonly done.
 
 #### Time Complexity
 
-- In the **worst-case**, the time complexity is **$O(n^2)$**, which can occur when the pivot is the smallest or largest element, resulting in highly unbalanced partitions. However, with effective pivot selection strategies, this scenario is rare in practice.
-- The **average-case** time complexity is **$O(n \log n)$**, which is expected when using a good pivot selection method that balances the partitions reasonably well.
-- In the **best-case**, the time complexity is also **$O(n \log n)$**, occurring when each pivot divides the array into two roughly equal-sized parts, leading to optimal partitioning.
+- In the **worst-case**, the time complexity is $O(n^2)$, which can occur when the pivot is the smallest or largest element, resulting in highly unbalanced partitions. However, with effective pivot selection strategies, this scenario is rare in practice.
+- The **average-case** time complexity is $O(n \log n)$, which is expected when using a good pivot selection method that balances the partitions reasonably well.
+- In the **best-case**, the time complexity is also $O(n \log n)$, occurring when each pivot divides the array into two roughly equal-sized parts, leading to optimal partitioning.
 
 #### Space Complexity
 
@@ -218,8 +316,9 @@ Heap Sort is a comparison-based sorting technique performed on a binary heap dat
 
 #### Conceptual Overview
 
-1. The first step is to **build a max heap**, which involves transforming the list into a max heap (a complete binary tree where each node is greater than or equal to its children). This is typically achieved using a bottom-up approach to ensure the heap property is satisfied.
-2. During **sorting**, the maximum element (the root of the heap) is swapped with the last element of the unsorted portion of the array, placing the largest element in its final position. The heap size is then reduced by one, and the unsorted portion is restructured into a max heap. This process continues until the heap size is reduced to one, completing the sort.
+1. The first step is to **build a max heap**, which involves transforming the list into a max heap (a complete binary tree where each node is greater than or equal to its children). This is typically achieved using a bottom-up approach to ensure the heap property is satisfied. *(Building the heap with Floyd’s bottom-up procedure costs Θ(*n*) time—lower than Θ(*n log n*)—so it never dominates the overall running time.)*
+
+2. During **sorting**, the maximum element (the root of the heap) is swapped with the last element of the unsorted portion of the array, placing the largest element in its final position. **After each swap, the newly “fixed” maximum stays at the end of the *same* array; the active heap is simply the prefix that remains unsorted.** The heap size is then reduced by one, and the unsorted portion is restructured into a max heap. This process continues until the heap size is reduced to one, completing the sort.
 
 #### Steps
 
@@ -229,19 +328,85 @@ Heap Sort is a comparison-based sorting technique performed on a binary heap dat
 4. "Heapify" the root of the tree, i.e., ensure the heap property is maintained.
 5. Repeat steps 2-4 until the size of the heap is one.
 
+```
+Initial array (size n = 5)                     index: 0 1 2 3 4
+        4                                        [4,10,3,5,1]
+      /   \
+    10     3
+   /  \
+  5    1
+
+↓ BUILD MAX-HEAP  (Θ(n))  —> heapSize = 5
+        10                                       [10,5,3,4,1]
+      /    \
+     5      3
+    / \
+   4   1
+```
+
+**Pass 1 extract-max**
+
+```
+swap 10 ↔ 1                               [1,5,3,4 | 10]   heapSize = 4
+                                           ↑ live heap ↑  ↑fixed↑
+heapify (1↔5, 1↔4)  →                      [5,4,3,1 | 10]
+
+        5
+      /   \
+     4     3
+    /
+   1
+```
+
+**Pass 2 extract-max**
+
+```
+swap 5 ↔ 1                                [1,4,3 | 5,10]   heapSize = 3
+heapify (1↔4)      →                      [4,1,3 | 5,10]
+
+        4
+      /   \
+     1     3
+```
+
+**Pass 3 extract-max**
+
+```
+swap 4 ↔ 3                                [3,1 | 4,5,10]   heapSize = 2
+(no heapify needed – root already ≥ child)
+
+        3
+       /
+      1
+```
+
+**Pass 4 extract-max**
+
+```
+swap 3 ↔ 1                                [1 | 3,4,5,10]   heapSize = 1
+(heap of size 1 is trivially a heap)
+```
+
+**Pass 5 extract-max**
+
+```
+Done – heapSize = 0
+Sorted array:                              [1,3,4,5,10]
+```
+
 #### Stability
 
 Heap sort is inherently unstable. Similar to quicksort, the relative order of equal items is not preserved because of the long-distance exchanges.
 
 #### Time Complexity
 
-- In the **worst-case**, the time complexity is **$O(n \log n)$**, regardless of the arrangement of the input data.
-- The **average-case** time complexity is also **$O(n \log n)$**, as the algorithm's structure ensures consistent performance.
-- In the **best-case**, the time complexity remains **$O(n \log n)$**, since building and deconstructing the heap is still necessary, even if the input is already partially sorted.
+- In the **worst-case**, the time complexity is $O(n \log n)$, regardless of the arrangement of the input data.
+- The **average-case** time complexity is also $O(n \log n)$, as the algorithm's structure ensures consistent performance.
+- In the **best-case**, the time complexity remains $O(n \log n)$, since building and deconstructing the heap is still necessary, even if the input is already partially sorted.
 
 #### Space Complexity
 
-$(O(1))$ - The sorting is done in-place, requiring only a constant amount of space for variables, regardless of the input size.
+$O(1)$ – The sorting is done in-place, requiring only a constant amount of auxiliary space. **This assumes an *iterative* `siftDown/heapify`; a recursive version would add an \$O(\log n)\$ call stack.**
 
 #### Implementation