6c:T481,Visual representations help cement understanding. Let's look at bubble sort through different lenses. **As a Series of Snapshots:** Consider sorting `[5, 1, 4, 2, 8]`: ``` Initial: [5, 1, 4, 2, 8] ↑ Compare & swap throughout Pass 1: [5, 1, 4, 2, 8] → [1, 5, 4, 2, 8] → [1, 4, 5, 2, 8] → [1, 4, 2, 5, 8] → [1, 4, 2, 5, 8] ~~~~~~~~ 8 is locked Pass 2: [1, 4, 2, 5, 8] → [1, 4, 2, 5, 8] → [1, 2, 4, 5, 8] → [1, 2, 4, 5, 8] ~~~~~~~ 5,8 locked Pass 3: [1, 2, 4, 5, 8] → [1, 2, 4, 5, 8] → [1, 2, 4, 5, 8] ~~~~~~~ 4,5,8 locked Pass 4: [1, 2, 4, 5, 8] → [1, 2, 4, 5, 8] ~~~~~~~~~ All locked - Done! ```6d:T50d,type Comparator = (a: T, b: T) => number; function bubbleSortGeneric( arr: T[], compare: Comparator = (a, b) => (a as any) - (b as any) ): T[] { const n = arr.length; for (let pass = 0; pass < n - 1; pass++) { let swapped = false; for (let i = 0; i < n - pass - 1; i++) { // Use the comparator: positive means a > b if (compare(arr[i], arr[i + 1]) > 0) { [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]; swapped = true; } } if (!swapped) break; } return arr; } // Example 1: Sort numbers (default) const numbers = [5, 2, 8, 1, 9]; bubbleSortGeneric(numbers); // [1, 2, 5, 8, 9] // Example 2: Sort strings by length const words = ["elephant", "cat", "dog", "butterfly"]; bubbleSortGeneric(words, (a, b) => a.length - b.length); // ["cat", "dog", "elephant", "butterfly"] // Example 3: Sort objects by property interface Person { name: string; age: number; } const people: Person[] = [ { name: "Alice", age: 30 }, { name: "Bob", age: 25 }, { name: "Charlie", age: 35 } ]; bubbleSortGeneric(people, (a, b) => a.age - b.age); // [{ name: "Bob", age: 25 }, { name: "Alice", age: 30 }, { name: "Charlie", age: 35 }]65:{"json":{"id":"seed_91e1333dd42b31a7f8a47d21861f4326","slug":"bubble-sort-intuition-analysis","category":"Data Structures & Algorithms","topic":"Bubble Sort — Intuition & Analysis","title":"Bubble Sort — Understanding the Simplest Sorting Algorithm","description":"Master bubble sort from first principles. Understand why bubbles rise, how adjacent swaps achieve ordering, analyze the O(n²) complexity in depth, and learn precisely when this 'inefficient' algorithm actually makes sense.","difficulty":"BEGINNER","estimatedMinutes":50,"pages":[{"id":"seed_c53711f29f633d59a2cf398585509d3a","title":"The Bubble Sort Algorithm","order":0,"content":[{"id":"opening-hook","title":"The Simplest Way to Sort","content":[{"data":{"content":"Imagine you're standing in a line of people sorted by height, but the line is currently in random order. How would you organize everyone if you could only compare and swap two adjacent people at a time?\n\nYou'd naturally start at one end, compare neighbors, swap if needed, and work your way down. After one complete pass, the tallest person would be at the end. Repeat until everyone is in place.\n\n**Congratulations—you've just invented bubble sort.**\n\nBubble sort is often the first sorting algorithm taught precisely because it mirrors this intuitive human process. It's not the most efficient algorithm, but its simplicity makes it an ideal vehicle for understanding fundamental sorting concepts that apply to every algorithm we'll study."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand the core intuition behind bubble sort, trace through its execution step by step, implement it in code, and visualize why it's called 'bubble' sort. This foundation prepares you for the detailed analysis in upcoming pages.","variant":"info"},"type":"callout"}]},{"id":"bubble-metaphor","title":"The Bubble Metaphor","content":[{"data":{"content":"The name \"bubble sort\" comes from a vivid physical metaphor: **larger elements \"bubble up\" to their correct positions** at the end of the array, just as air bubbles rise through water to the surface.\n\nConsider a glass of carbonated water. Small bubbles form at the bottom and rise to the top because they're lighter than the surrounding liquid. Similarly, in bubble sort:\n\n- We repeatedly pass through the array from left to right\n- We compare adjacent pairs of elements\n- If a larger element is on the left, we swap it with its smaller neighbor\n- This causes larger elements to gradually migrate rightward\n- After each complete pass, the largest unsorted element reaches its final position\n\nThe beauty of this metaphor is that it precisely describes the algorithm's behavior: large values \"float\" to the right, while small values effectively \"sink\" to the left."},"type":"text"},{"data":{"icon":"Lightbulb","title":"Visualizing the Bubble Effect","content":"Picture an array as a horizontal tube of water. Each element is a bubble whose size corresponds to its value. As you pass through repeatedly, large bubbles push past smaller ones, rising toward the right end of the tube. After enough passes, all bubbles are sorted by size—largest at the right.","variant":"tip"},"type":"callout"},{"data":{"content":"**Why this metaphor matters for understanding:**\n\nThe bubble metaphor isn't just a cute name—it reveals the algorithm's fundamental mechanism. Each pass guarantees that at least one element (the largest remaining unsorted element) reaches its final position. This is known as the **loop invariant** of bubble sort: after k passes, the k largest elements are in their correct, final positions at the end of the array.\n\nUnderstanding this invariant is crucial because:\n1. It explains why the algorithm terminates\n2. It shows how progress is made with each pass\n3. It reveals optimization opportunities (we'll explore these later)"},"type":"text"}],"titleType":"number","titleNumber":1},{"id":"algorithm-definition","title":"Formal Algorithm Definition","content":[{"data":{"content":"Let's formalize the bubble sort algorithm precisely. Given an array A of n elements, bubble sort works as follows:"},"type":"text"},{"data":{"type":"ordered","items":["**Outer Loop**: Repeat the following process (n-1) times, where n is the array length.","**Inner Loop**: For each position i from 0 to (n - current_pass - 1), compare A[i] with A[i+1].","**Comparison**: If A[i] > A[i+1] (for ascending order), the elements are out of order.","**Swap**: Exchange A[i] and A[i+1] to correct the local ordering.","**Termination**: After (n-1) complete passes, the array is guaranteed to be sorted."],"title":{"icon":"Code","text":"Bubble Sort Algorithm Steps","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**Why (n-1) passes?**\n\nAfter each pass, one more element is guaranteed to be in its final position. After (n-1) passes, (n-1) elements are correctly placed. The remaining element must also be correct (there's only one spot left), so the array is sorted.\n\n**Why does the inner loop shrink?**\n\nAfter pass k, the k largest elements are at the end in sorted order. We don't need to compare them anymore—they're already in place. This optimization reduces unnecessary comparisons, though it doesn't change the asymptotic complexity."},"type":"text"},{"data":{"code":"function bubbleSort(arr: number[]): number[] {\n const n = arr.length;\n \n // Outer loop: repeat (n-1) times\n for (let pass = 0; pass < n - 1; pass++) {\n // Inner loop: compare adjacent pairs\n // Note: we only go up to (n - pass - 1) because\n // the last 'pass' elements are already sorted\n for (let i = 0; i < n - pass - 1; i++) {\n // Compare adjacent elements\n if (arr[i] > arr[i + 1]) {\n // Swap if out of order\n [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];\n }\n }\n }\n \n return arr;\n}\n\n// Example usage\nconst unsorted = [64, 34, 25, 12, 22, 11, 90];\nconsole.log(bubbleSort(unsorted));\n// Output: [11, 12, 22, 25, 34, 64, 90]","title":"Basic Bubble Sort Implementation","language":"typescript"},"type":"code"},{"data":{"icon":"Info","title":"Implementation Details Matter","content":"Notice how we use array destructuring `[arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]` for swapping. This is elegant but creates a temporary array. In performance-critical code, you might use a temporary variable instead. The algorithm remains the same; only the swap mechanism differs.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"step-by-step-trace","title":"Step-by-Step Execution Trace","content":[{"data":{"content":"The best way to internalize an algorithm is to trace through it manually. Let's sort a small array step by step, tracking every comparison and swap.\n\n**Initial Array:** `[5, 3, 8, 4, 2]`\n\nWe'll perform bubble sort and observe how the largest element bubbles to the end in each pass."},"type":"text"},{"data":{"rows":[["1.1","5 vs 3","Swap (5 > 3)","[3, 5, 8, 4, 2]"],["1.2","5 vs 8","No swap (5 < 8)","[3, 5, 8, 4, 2]"],["1.3","8 vs 4","Swap (8 > 4)","[3, 5, 4, 8, 2]"],["1.4","8 vs 2","Swap (8 > 2)","[3, 5, 4, 2, 8]"]],"caption":"Pass 1: Largest element (8) bubbles to the end","headers":["Step","Compare","Action","Array State"]},"type":"table"},{"data":{"content":"After Pass 1: `[3, 5, 4, 2, 8]` — Notice that **8** is now in its final position.\n\nThe largest element encountered the comparison gauntlet and was pushed all the way to the right. This is the \"bubbling\" action in its purest form."},"type":"text"},{"data":{"rows":[["2.1","3 vs 5","No swap (3 < 5)","[3, 5, 4, 2, 8]"],["2.2","5 vs 4","Swap (5 > 4)","[3, 4, 5, 2, 8]"],["2.3","5 vs 2","Swap (5 > 2)","[3, 4, 2, 5, 8]"]],"caption":"Pass 2: Second largest (5) reaches its position","headers":["Step","Compare","Action","Array State"]},"type":"table"},{"data":{"content":"After Pass 2: `[3, 4, 2, 5, 8]` — Now **5** and **8** are in their final positions.\n\nNotice we only made 3 comparisons in Pass 2 (not 4). Since 8 is already sorted, we don't need to include it."},"type":"text"},{"data":{"rows":[["3.1","3 vs 4","No swap (3 < 4)","[3, 4, 2, 5, 8]"],["3.2","4 vs 2","Swap (4 > 2)","[3, 2, 4, 5, 8]"]],"caption":"Pass 3: Third largest (4) finds its place","headers":["Step","Compare","Action","Array State"]},"type":"table"},{"data":{"content":"After Pass 3: `[3, 2, 4, 5, 8]` — Elements **4, 5, 8** are now in final positions."},"type":"text"},{"data":{"rows":[["4.1","3 vs 2","Swap (3 > 2)","[2, 3, 4, 5, 8]"]],"caption":"Pass 4: Final pass completes the sort","headers":["Step","Compare","Action","Array State"]},"type":"table"},{"data":{"content":"**Final Result:** `[2, 3, 4, 5, 8]` ✓\n\n**Total Statistics for this sort:**\n- **Passes:** 4 (which is n-1 for n=5)\n- **Comparisons:** 4 + 3 + 2 + 1 = 10 (which is n(n-1)/2)\n- **Swaps:** 7 (depends on initial disorder)"},"type":"text"},{"data":{"icon":"CheckCircle","title":"Key Observation","content":"Notice the pattern: each pass makes fewer comparisons than the last because more elements become \"frozen\" in their final positions. Pass 1 had 4 comparisons, Pass 2 had 3, Pass 3 had 2, Pass 4 had 1. The total is always n(n-1)/2 for a complete sort.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"loop-invariant","title":"Understanding the Loop Invariant","content":[{"data":{"content":"A **loop invariant** is a property that remains true before and after each iteration of a loop. Understanding invariants is crucial for proving algorithm correctness and for developing algorithmic intuition.\n\n**Bubble Sort's Loop Invariant:**\n\n> After the k-th pass of the outer loop, the k largest elements are in their final sorted positions at the end of the array.\n\nLet's prove this invariant holds:"},"type":"text"},{"data":{"items":["**Initialization (Base Case):** Before any passes (k=0), zero elements are guaranteed to be in final position. The invariant trivially holds.","**Maintenance:** Assume after pass k, the k largest elements are at the end in sorted order. During pass (k+1), we compare all adjacent pairs in the unsorted portion. The largest element in this portion will be compared favorably with everyone and pushed to position (n-k-1), which is its final position. Now (k+1) largest elements are sorted at the end.","**Termination:** After (n-1) passes, (n-1) largest elements are in their final positions. The smallest element must occupy the only remaining position—the first slot. The array is completely sorted."],"title":{"icon":"Shield","text":"Invariant Proof Structure","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**Why invariants matter in practice:**\n\nUnderstanding the loop invariant helps you:\n1. **Debug with confidence** — If your sort fails, check if the invariant holds after each pass\n2. **Optimize correctly** — You can skip sorted regions because the invariant guarantees they're done\n3. **Extend the algorithm** — Adding early termination (if no swaps occur) works because the invariant tells you when sorting is complete\n4. **Compare algorithms** — Different sorting algorithms have different invariants; understanding them reveals their true nature"},"type":"text"},{"data":{"icon":"Info","title":"Inner Loop Invariant","content":"The inner loop also has an invariant: after comparing position j with position j+1, the largest element among positions 0 through j+1 is at position j+1. This is how the largest element \"bubbles\" rightward during each pass.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"visual-understanding","title":"Visualizing the Sorting Process","content":[{"data":{"content":"$6c"},"type":"text"},{"data":{"content":"**As a Bar Chart (Conceptual):**\n\nImagine each element as a bar whose height represents its value:\n\n```\nInitial: After Pass 1: After Pass 2: Final:\n █ █ █ █\n█ █ █ █ █ █ █ █ █ █ █\n█ █ █ █ █ █ █ █ █ █ █ █ █\n█ █ █ █ █ █ █ █ █ █ █ █ █\n5 1 4 2 8 1 4 2 5 8 1 2 4 5 8 1 2 4 5 8\n```\n\nWatch how the tallest bar (8) moves to the right first, then 5, then 4, and so on. The right side of the array progressively becomes a sorted \"staircase\" of increasing bars."},"type":"text"},{"data":{"icon":"Lightbulb","title":"The Sorted Region Grows","content":"Think of the array as having two regions: an unsorted left portion and a sorted right portion. Initially, the entire array is unsorted. With each pass, the sorted region grows by one element as the next-largest value finds its home. This mental model applies to many sorting algorithms.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"alternative-implementations","title":"Implementation Variations","content":[{"data":{"content":"While the core algorithm remains the same, bubble sort can be implemented in various ways. Understanding these variations builds flexibility and deeper insight."},"type":"text"},{"data":{"code":"function bubbleSortOptimized(arr: number[]): number[] {\n const n = arr.length;\n \n for (let pass = 0; pass < n - 1; pass++) {\n let swapped = false; // Track if any swap occurred\n \n for (let i = 0; i < n - pass - 1; i++) {\n if (arr[i] > arr[i + 1]) {\n [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];\n swapped = true;\n }\n }\n \n // If no swaps occurred, array is already sorted\n if (!swapped) {\n break; // Early termination!\n }\n }\n \n return arr;\n}\n\n// For already-sorted arrays, this completes in O(n) time!\nconst sorted = [1, 2, 3, 4, 5];\nbubbleSortOptimized(sorted); // Only one pass needed","title":"Variation 1: Optimized with Early Termination","language":"typescript"},"type":"code"},{"data":{"content":"The optimized version tracks whether any swaps occurred during a pass. If a complete pass makes no swaps, the array must already be sorted, and we can terminate early. This optimization is significant:\n\n- **Already sorted arrays:** O(n) time instead of O(n²)\n- **Nearly sorted arrays:** Close to O(n) time\n- **Random arrays:** Still O(n²), but might terminate a few passes early"},"type":"text"},{"data":{"code":"function bubbleSortLastSwap(arr: number[]): number[] {\n const n = arr.length;\n let lastUnsortedIndex = n - 1;\n \n while (lastUnsortedIndex > 0) {\n let lastSwapIndex = 0;\n \n for (let i = 0; i < lastUnsortedIndex; i++) {\n if (arr[i] > arr[i + 1]) {\n [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];\n lastSwapIndex = i;\n }\n }\n \n // Everything after lastSwapIndex is already sorted\n lastUnsortedIndex = lastSwapIndex;\n }\n \n return arr;\n}\n\n// This leverages the insight that elements after the last\n// swap are already in their correct positions","title":"Variation 2: Tracking Last Swap Position","language":"typescript"},"type":"code"},{"data":{"content":"This variation is even smarter: it remembers where the last swap occurred. Since no swaps happened after that point, all elements beyond it must already be sorted. The next pass only needs to go up to the last swap position.\n\nThis is particularly effective for arrays with a sorted \"tail\":\n- Array: `[3, 1, 2, 4, 5, 6, 7, 8, 9, 10]`\n- After first pass, lastSwapIndex = 1\n- Second pass only checks indices 0-1\n- Dramatically fewer comparisons than standard bubble sort"},"type":"text"},{"data":{"code":"function bubbleSortDescending(arr: number[]): number[] {\n const n = arr.length;\n \n for (let pass = 0; pass < n - 1; pass++) {\n for (let i = 0; i < n - pass - 1; i++) {\n // Change comparison direction: < instead of >\n if (arr[i] < arr[i + 1]) {\n [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];\n }\n }\n }\n \n return arr;\n}\n\n// Example: [3, 1, 4, 1, 5] → [5, 4, 3, 1, 1]","title":"Variation 3: Descending Order Sort","language":"typescript"},"type":"code"},{"data":{"icon":"Info","title":"The Core Remains the Same","content":"All variations share the same fundamental approach: compare adjacent elements and swap if out of order. The variations optimize specific scenarios or change the sort order. Understanding the base algorithm deeply makes all variations intuitive.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":6},{"id":"generic-implementation","title":"Generic Bubble Sort for Any Type","content":[{"data":{"content":"Real-world sorting often involves complex objects, not just numbers. Let's build a generic bubble sort that works with any comparable type."},"type":"text"},{"data":{"code":"$6d","title":"Generic Bubble Sort with Comparator","language":"typescript"},"type":"code"},{"data":{"content":"**Understanding the Comparator Pattern:**\n\nA comparator is a function that takes two elements and returns:\n- **Negative number:** first element should come before second\n- **Zero:** elements are equal (order doesn't matter)\n- **Positive number:** first element should come after second\n\nThis pattern is used universally in sorting APIs across languages:\n- JavaScript: `Array.prototype.sort(compareFn)`\n- Java: `Comparator` interface\n- Python: `key` parameter or `cmp_to_key`\n- C++: `std::sort` with comparison function"},"type":"text"},{"data":{"icon":"AlertCircle","title":"Comparator Consistency is Critical","content":"Your comparator must be consistent: if compare(a, b) < 0, then compare(b, a) > 0. Inconsistent comparators can cause infinite loops or incorrect results. Also ensure transitivity: if a < b and b < c, then a < c.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":7},{"id":"common-mistakes","title":"Common Implementation Mistakes","content":[{"data":{"content":"Even simple algorithms have pitfalls. Here are common mistakes when implementing bubble sort and how to avoid them."},"type":"text"},{"data":{"left":[{"data":{"items":["**Off-by-one in outer loop:** Using `pass < n` instead of `pass < n - 1` wastes one unnecessary pass","**Off-by-one in inner loop:** Using `i <= n - pass - 1` causes array index out of bounds when accessing `arr[i + 1]`","**Forgetting the shrinking boundary:** Using `i < n - 1` for every pass ignores that the right side is already sorted","**Wrong swap direction:** Swapping when `arr[i] < arr[i+1]` produces descending order","**Modifying array length during sort:** Leads to unpredictable behavior"],"title":{"icon":"XCircle","text":"Common Mistakes","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"}],"right":[{"data":{"items":["**Outer loop:** `for (pass = 0; pass < n - 1; pass++)` — exactly n-1 passes needed","**Inner loop:** `for (i = 0; i < n - pass - 1; i++)` — stay within bounds","**Shrinking boundary:** Subtract `pass` from inner loop limit to skip sorted elements","**Ascending order:** Swap when `arr[i] > arr[i + 1]`; reverse for descending","**Immutable length:** Cache `n = arr.length` before sorting begins"],"title":{"icon":"CheckCircle","text":"Correct Approaches","type":"icon","color":"primary","variant":"outline-circle"},"variant":"glass"},"type":"list"}]},"type":"two-column"},{"data":{"code":"// BUG: This will crash!\nfunction bubbleSortBuggy(arr: number[]): number[] {\n const n = arr.length;\n \n for (let pass = 0; pass < n; pass++) { // ❌ Should be n - 1\n for (let i = 0; i <= n - 1; i++) { // ❌ Should be < n - pass - 1\n if (arr[i] > arr[i + 1]) { // ❌ arr[n] doesn't exist!\n [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];\n }\n }\n }\n return arr;\n}\n\n// When i = n - 1, we access arr[n] which is undefined\n// Comparing arr[n-1] > undefined returns false, avoiding obvious crash\n// But arr[n-1] might incorrectly not be swapped with its actual neighbor","title":"Demonstrating the Off-by-One Bug","language":"typescript"},"type":"code"},{"data":{"icon":"Lightbulb","title":"Testing Edge Cases","content":"Always test your implementation with: empty array [], single element [5], two elements [5, 3] and [3, 5], already sorted array, reverse sorted array, array with duplicates, and large arrays. These edge cases catch most bugs.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":8},{"id":"summary","title":"Summary: The Bubble Sort Algorithm","content":[{"data":{"content":"We've covered bubble sort thoroughly. Let's consolidate the key takeaways:"},"type":"text"},{"data":{"type":"ordered","items":["**The bubble metaphor is literal:** Larger elements \"bubble up\" to the right end of the array, just as air bubbles rise through water.","**Simple algorithm, simple implementation:** Compare adjacent pairs, swap if out of order, repeat until sorted. Two nested loops, one comparison, one swap.","**The loop invariant guarantees correctness:** After k passes, the k largest elements are in their final positions. This is why (n-1) passes guarantee a sorted array.","**Optimizations exist:** Early termination when no swaps occur, tracking last swap position—these help in best-case scenarios but don't change worst-case complexity.","**Generic implementations are straightforward:** Use a comparator function to sort any type of data, not just numbers.","**Watch for off-by-one errors:** The inner loop especially is prone to boundary mistakes. Test edge cases rigorously."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's next:**\n\nNow that you understand the bubble sort algorithm conceptually and can implement it, we'll dive deeper into **how it works mechanically**. The next page explores the swapping mechanism—the fundamental operation that makes bubble sort (and many other algorithms) possible."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand the bubble sort algorithm: its metaphor, mechanism, invariants, and implementation. You've traced through examples, seen variations, and learned to avoid common mistakes. Next, we'll examine the adjacent swap operation in detail.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":9}],"isLocked":false},{"id":"seed_ef7e8ea6d060a509f09a1ae1b8dea499","title":"Swapping Adjacent Elements","order":1,"content":null,"isLocked":true},{"id":"seed_9327f581cc491a2116a23fb780871030","title":"Time Complexity — O(n²) Average and Worst","order":2,"content":null,"isLocked":true},{"id":"seed_0a9547cd2cccac0d8d5d1927f83f28d1","title":"When Bubble Sort Is Acceptable (Hint: Rarely)","order":3,"content":null,"isLocked":true}]}}