Software architect writing about Linux, Kubernetes, distributed systems, algorithms, and other technical things. Zola 2026-01-26T00:00:00+00:00 https://tofchaliss.com/atom.xml 2026-01-26T00:00:00+00:00 2026-01-26T00:00:00+00:00 Franco Chalissery https://tofchaliss.com/blog/sorting/ <p>This blog is a snapshot of all well known sorting algorithms and its attributes.</p> <div style="overflow-x: auto"> <table> <thead> <tr> <th rowspan="2">Algorithm</th> <th colspan="3">Time complexity</th> <th rowspan="2">Space complexity</th> <th rowspan="2">Attributes</th> </tr> <tr> <th>Best case</th> <th>Average case</th> <th>Worst case</th> </tr> </thead> <tbody> <tr> <td><a href="https://github.com/tofchaliss/dsa-algo/blob/main/sorting/insertionsort.py">Insertion Sort</a></td> <td>O(n)</td> <td>O(n²)</td> <td>O(n²)</td> <td>O(1)</td> <td>Stable, In-Place, Comparison based, used as base case for hybrid sort (timsort)</td> </tr> <tr> <td><a href="https://github.com/tofchaliss/dsa-algo/blob/main/sorting/selectionsort.py">Selection Sort</a></td> <td>O(n²)</td> <td>O(n²)</td> <td>O(n²)</td> <td>O(1)</td> <td>Not Stable, In-Place, Comparison based, used in heavy memory write use cases , used in small dataset</td> </tr> <tr> <td><a href="https://github.com/tofchaliss/dsa-algo/blob/main/sorting/bubblesort.py">Bubble Sort</a></td> <td>O(n)</td> <td>O(n²)</td> <td>O(n²)</td> <td>O(1)</td> <td>Stable, In-Place, Comparison based</td> </tr> <tr> <td><a href="https://github.com/tofchaliss/dsa-algo/blob/main/sorting/mergesort.py">Merge Sort</a></td> <td>O(n log n)</td> <td>O(n log n)</td> <td>O(n log n)</td> <td>O(n)</td> <td>Stable, Not In-Place, Comparison based, large dataset, external sorting (files, directories)</td> </tr> <tr> <td><a href="https://github.com/tofchaliss/dsa-algo/blob/main/sorting/quicksort.py">Quick Sort</a></td> <td>O(n log n)</td> <td>O(n log n)</td> <td>O(n²)</td> <td>O(log n) (average)<br>O(n) (worst)</td> <td>Not Stable, In-Place, Comparison based, general purpose</td> </tr> <tr> <td><a href="https://github.com/tofchaliss/dsa-algo/blob/main/sorting/heapsort.py">Heap Sort</a></td> <td>O(n log n)</td> <td>O(n log n)</td> <td>O(n log n)</td> <td>O(1)</td> <td>Not Stable, In-Place, Comparison based, when guaranteed to be O(n log n) and constant space requirement</td> </tr> <tr> <td><a href="https://github.com/tofchaliss/dsa-algo/blob/main/sorting/countingsort.py">Counting Sort</a></td> <td>O(n + k)</td> <td>O(n + k)</td> <td>O(n + k)</td> <td>O(n + k)</td> <td>Stable, Not In-Place, Not Comparison based, Integer with small know range (score, age)</td> </tr> <tr> <td><a href="https://github.com/tofchaliss/dsa-algo/blob/main/sorting/bucketsort.py">Bucket Sort</a></td> <td>O(n + k)</td> <td>O(n + k)</td> <td>O(n²)</td> <td>O(n + k)</td> <td>Depends on hash function(Stable or not), Not In-Place, Not Comparison based, Uniformly distributed floating point numbers</td> </tr> <tr> <td><a href="https://github.com/tofchaliss/dsa-algo/blob/main/sorting/radixsort.py">Radix Sort</a></td> <td>O(d · (n + k))</td> <td>O(d · (n + k))</td> <td>O(d · (n + k))</td> <td>O(n + k)</td> <td>Stable, Not In-Place, Not Comparison based, Integer with small know range (id, phone number)</td> </tr> </tbody> </table> </div> 2020-12-14T00:00:00+00:00 2020-12-14T00:00:00+00:00 Franco Chalissery https://tofchaliss.com/blog/sorting-stability/ <p>There are many sorting algorithms out there that are widely accepted: Insertion sort, quick sort, heap sort, merge sort, bucket sort… and so on and so forth. There are <em>a lot</em> of qualities of each sorting algorithm that allow you to choose what algorithm fits your requirements, but one of the sorting algorithm qualities I want to talk about in this post is <strong>stability</strong>.</p> <h2 id="sorting-stability"><a class="zola-anchor" href="#sorting-stability" aria-label="Anchor link for: sorting-stability"><i class="icon"></i></a> Sorting stability</h2> <p>Stability of a sorting algorithmn is the label that indicates whether or not it will preserve the order of two or more elements in the array <strong>if they have equal sorting keys</strong>. A sorting algorithm is <strong>stable</strong> if it preserves the order of multiple elements with the same keys. Conversely, a sorting algorithm is <strong>unstable</strong> if it cannot guarantee order preservation of multiple elements with equal keys.</p> <p>An example in real life: There is a line of people that need to be ordered by age. If there are two people with the same age standing in line, the sorter would be using a stable approach if there is a guarantee that their order in line relative to each remains the same.</p> <h2 id="when-does-stability-matter"><a class="zola-anchor" href="#when-does-stability-matter" aria-label="Anchor link for: when-does-stability-matter"><i class="icon"></i></a> When does stability matter?</h2> <p>Sorting stability is interesting by itself, but when do we care about it? We care in a situation when we <em>require</em> the output to have the guarantee of preserving order for duplicate keys.</p> <h3 id="example-data"><a class="zola-anchor" href="#example-data" aria-label="Anchor link for: example-data"><i class="icon"></i></a> Example data</h3> <p>Let’s see another example and dissect it. Let’s say we have an array of data, where each element has two fields: <code>Name</code> and <code>State</code>. Here is a visual respresentation of the data:</p> <p><img src="/images/sort_stability_01.png" alt="Dataset" /></p> <h3 id="requirement"><a class="zola-anchor" href="#requirement" aria-label="Anchor link for: requirement"><i class="icon"></i></a> Requirement</h3> <p>Sort the data by state and then by name, so that the final data is ordered by state first and then by name.</p> <h3 id="approach"><a class="zola-anchor" href="#approach" aria-label="Anchor link for: approach"><i class="icon"></i></a> Approach</h3> <p>This data will be sorted twice so that the requirements can be met:</p> <ol> <li>Sort first by <code>Name</code></li> <li>Sort second by <code>State</code></li> </ol> <p>The first sort by <code>Name</code> doesn’t require a stable sorting algorithm, as the order for duplicate sorting keys (names) doesn’t matter. So in this case, we could do a heap sort (a naturally unstable sorting algorithmn) on this array by name.</p> <p>The output from sorting by <code>Name</code> is:</p> <p><img src="/images/sort_stability_03.png" alt="Dataset sorted by Name" /></p> <p>The second sort by <code>State</code> is where it can get interesting. If we were to try a heap sort by <code>State</code>, this is how we would setup our complete binary tree:</p> <p><img src="/images/sort_stability_02.png" alt="Heap sort start by State" /></p> <p>If we were to continue the heap sort by <code>State</code>, we would end up with an array sorted like:</p> <p><img src="/images/sort_stability_04.png" alt="Output of heap sort by state" /></p> <p>Yes, the array is sorted correctly by <code>State</code>, but let’s see how the elements themselves transitioned:</p> <p><img src="/images/sort_stability_05.png" alt="Element transition" /></p> <p>The fact that elements with the same sorting key (<code>State</code>) have overlapping sections to the destination array elements indicates that <strong>their order was not preserved</strong>, showing that this is a <strong>unstable</strong> sorting algorithmn.</p> <h3 id="the-solution"><a class="zola-anchor" href="#the-solution" aria-label="Anchor link for: the-solution"><i class="icon"></i></a> The solution</h3> <p>If we were to look back at the requirements, the heap sort by <code>State</code> does not work: The output is sorted by <code>State</code> but it is no longer sorted also by <code>Name</code> within each <code>State</code>.</p> <p>Let’s try doing a second sort (by <code>State</code>) with a naturally stable sorting algorithm: Merge sort. The output of the second sort if we were to use a merge sort (instead of a heap sort) would be:</p> <p><img src="/images/sort_stability_06.png" alt="Merge sort output" /></p> <p>Of course, <code>State</code> is correctly sorted but now let’s see how the elments transitioned from being sorted by <code>Name</code> to a merge sort by <code>State</code>:</p> <p><img src="/images/sort_stability_07.png" alt="Element transition merge sort" /></p> <p>Now because we used a stable sorting algorithmn (merge sort) on <code>State</code>, we preserved the order of elements with the same <code>State</code> key value, giving us the desired output of a dataset that is sorted by state and then by name.</p> <h2 id="summary"><a class="zola-anchor" href="#summary" aria-label="Anchor link for: summary"><i class="icon"></i></a> Summary</h2> <p>Sorting algorithmns are a large part of computing, and understanding the behaviors of different algorithms will help in determining the right one for your requirements.</p>