Comb Sort is the poster boy for the all-American child.

Unlike his elder brother Shell Sort, Comb Sort is a star athlete. He started as the quarterback for his high school football team when he was a sophomore. But more than that, he has everything he thought he could ever want, at least until recently. He’s the junior prom king, the one voted “best athlete” in the yearbook, everything. Life has been easy for him so far.

Yet, something is bothering him. Something that, until recently, he couldn’t describe.

He’s not the smartest guy, and he knows this. His grades are mostly Cs and Ds, and he understands that that doesn’t bode well for his future. His p

rents are high-achievers, his brother is a straight-A student, and he’s… what? A star athlete? That won’t last forever. What happens when he can no longer get by on physical prowess?

So, he reads. He studies. He’s putting more time into making good test scores and less time into sports. It’s not working yet (his last test was a C+), but he’s hopeful that it will, and soon. He can’t get through life on athletic skills alone. He’s sorting out his life, one piece at a time.

The Rundown

• Created By: Włodzimierz Dobosiewicz (1980)
• **Type: **Exchange
• Stable? YES
• Best-Case**: **O(n)
• Average-Case:  O(n2)
• **Worst-Case: **O(n2)
• Space Complexity**: **O(1)
• Sample Project: Over on GitHub

Get “The Catch Block”, My Weekly Newsletter!

Plus my eBook “The Daily Design Pattern”, early access, new posts in your inbox, and more for becoming a paid subscriber.

Go!

I will not spam, sell your email, etc.

Algorithm

1. DETERMINE the appropriate gap size h by using a set shrink factor k.
2. COMPARE each pair of elements that are h distance from each other.
3. SWAP those elements if they are in the wrong order.
4. COMPLETE a pass through the array with the selected h.
5. SHRINK the gap size _h _using shrink factor k.
6. IF h is not 1, GOTO step 2.
7. CONTINUE until h is 1 AND a pass through the array results in no swaps.

Visualization

You can see from this animation why this algorithm got the name “Comb Sort”: the comparison distance look like two prongs in a comb. You can also see that this is a not-very-effective sort: it has to do many passes through all elements in order to fully sort this list. In fact, we would most likely consider Comb Sort to be a “naive” sort, on the same level as Selection Sort.

Also check out the “audibilization” of this sort from YouTube:

Finally, reader James Curran kindly created a visualization for this sort; it looks like this:

Implementation

class CombSort
{
static int GetNextGap(int gap)
{
//The “shrink factor”, empirically shown to be 1.3
gap = (gap * 10) / 13;
if (gap < 1)
{
return 1;
}
return gap;
}

static void Sort(int[] array)
{
    int length = array.Length;

    int gap = length;

    //We initialize this as true to enter the while loop.
    bool swapped = true;

    while (gap != 1 || swapped == true)
    {
        gap = GetNextGap(gap);

        //Set swapped as false.  Will go to true when two values are swapped.
        swapped = false;

        //Compare all elements with current gap 
        for (int i = 0; i < length - gap; i++)
        {
            if (array[i] > array[i + gap])
            {
                //Swap
                int temp = array[i];
                array[i] = array[i + gap];
                array[i + gap] = temp;

                swapped = true;
            }
        }
    }
}

public static void Main()
{
    int[] array = { 10, 28, 1, 55, 6, 21, 36, 3, 45, 15, 0 };

    Console.WriteLine("Comb Sort");

    CommonFunctions.PrintInitial(array);

    Sort(array);

    CommonFunctions.PrintFinal(array);
    Console.ReadLine();

}

}

### Time and Space Complexity

The worst case of _O(n2) _make intuitive sense, at least to me. Given that comb sort is based on bubble sort, we would expect poor time complexities for it. But the average case is interesting because it introduces a form of notation I hadn't seen before: big-omega.

Remember that the average time complexity for this algorithm is _Ω(n2/2p). _This is read aloud as "big-omega of n-squared over 2 to the power of p". But what does big-omega mean? In short, big-omega represents the best possible case of the complexity. On average, comb sort has been shown to perform no better than n2/2p, where _n_ is the length of the unsorted array and _p_ is the number of times we have to decrement the gap.

This is not a great time, and because it's the best possible case on average, we can conclude that Comb Sort is not an efficient sorting algorithm.

#exchange sorts #algorithms