Difference between Comb Sort and Shell Sort

In this tutorial, we will discuss comb sort, shell sort and the difference between them.

Comb Sort is a more complex version of bubble Sort. Bubble Sort evaluates all nearby values, whereas comb sort eliminates all turtle values or small values near the end of the list.

It is a contrast sorting algorithm that mostly improves on bubble sort. To sort the given array, bubble sort uses a comparison between nearby elements. As a result, the gap size between the components that are compared in bubble sort is 1. By employing a gap larger than one, comb sort outperforms bubble sort. The comb sort gap begins with the higher value and diminishes by a factor of 1.3. It indicates that when each phase is completed, the gap is divided by the shrink factor 1.3. The iteration process is repeated until the gap is equal to one.

By running comb sort on 200,000 random lists, the shrink factor is found to be 1.3. Comb sort outperforms bubble sort, although its temporal complexity in the average and worst cases remains O(n²).

Shell sort is an extension of insertion sort that addresses insertion sort's disadvantages by evaluating elements separated by multiple locations.

It is an expanded version of the insertion sort sorting algorithm. Insertion sort's average time complexity has been reduced thanks to shell sort. It is a contrast and in-place sorting algorithm, comparable to insertion sort. Shell sort works well for moderate data sets.

Elements in insertion sort can only be moved forward by one position at a time. Many moves are necessary to transport an element to a distant point, which increases the algorithm's processing time. However, shell sort eliminates this disadvantage of insertion sort. It also enables for the moving and switching of distant elements.

Implementation of the Comb Sort

Let's look at some Comb sort codes written in various coding languages.

C Programming Language:

#include <stdio.h>  
#include<math.h>  
  
int updatedGap(int gap)  
{  
    gap = floor(gap/1.3);  
  
    if (gap < 1)  
        return 1;  
    return gap;  
}  
void combSort(int a[], int n)  
{  
    int gap = n; 
  
    int swapped = 1;  
  
    while (gap != 1 || swapped == 1)  
    {  
        gap = updatedGap(gap); 
        swapped = 0;  
  
        for (int i = 0; i < n-gap; i++) 
        {  
            if (a[i] > a[i+gap]) 
            {  
                int temp = a[i];    
                a[i] = a[i+gap];    
                a[i+gap] = temp;    
                swapped = 1;  
            }  
        }  
    }  
}  
void printArr(int a[], int n) 
{  
    for (int i=0; i<n; i++)  
        printf("%d ", a[i]);  
}  
  
int main()
{  
    int a[] = {49, 11, 24, 44, 29, 27, 2};  
    int n = sizeof(a)/sizeof(a[0]);  
    printf("Before sorting array elements are - \n");  
    printArr(a, n);  
    combSort(a, n);  
    printf("\nAfter sorting array elements are - \n");    
    printArr(a, n);  
    return 0;  
}  

Output:

The output of the following code will be -

Before sorting array elements are - 
49 11 24 44 29 27 2 
After sorting array elements are - 
2 11 24 27 29 44 49

C++ Program:

#include <iostream>  
#include<cmath>  
using namespace std;  
  
int updatedGap(int gap)  
{  
    gap = floor(gap/1.3);  
  
    if (gap < 1)  
        return 1;  
    return gap;  
}  
void combSort(int a[], int n)  
{  
    int gap = n;
  
    int swapped = 1;  
  
    while (gap != 1 || swapped == 1)  
    {  
        gap = updatedGap(gap); 
        swapped = 0;  
  
        for (int i = 0; i < n-gap; i++)   
        {  
            if (a[i] > a[i+gap])
            {  
                int temp = a[i];    
                a[i] = a[i+gap];    
                a[i+gap] = temp;    
                swapped = 1;  
            }  
        }  
    }  
}  
void printArr(int a[], int n) 
{  
    for (int i=0; i<n; i++)  
        cout << a[i] << " ";  
}  
  
int main()  
{  
    int a[] = {48, 10, 23, 43, 28, 26, 1};  
    int n = sizeof(a)/sizeof(a[0]);  
    cout << "Before sorting array elements are - \n";  
    printArr(a, n);  
    combSort(a, n);  
    cout << "\nAfter sorting array elements are - \n";    
    printArr(a, n);  
    return 0;  
}  

Output:

The output of the following code will be -

Before sorting array elements are - 
49 11 24 44 29 27 2 
After sorting array elements are - 
2 11 24 27 29 44 49

Time Complexity:

Best Case: θ(n log n).
Average Case: Ω(n2/2p); p = number of increments.
Worst Case: O(n²).

The comb sort has a space complexity of O(1).

Implementation of the Shell Sort

Let's look at some Shell sort codes written in various coding languages.

C Programming Language:

#include <stdio.h>    
int shell(int a[], int n)  
{  
    for (int interval = n/2; interval > 0; interval /= 2)  
    {  
        for (int i = interval; i < n; i += 1)  
        {  
            int temp = a[i];  
            int j;        
            for (j = i; j >= interval && a[j - interval] > temp; j -= interval)  
                a[j] = a[j - interval];  
              
            a[j] = temp;  
        }  
    }  
    return 0;  
}  
void printArr(int a[], int n)
{  
    int i;  
    for (i = 0; i < n; i++)  
        printf("%d ", a[i]);  
}    
int main()  
{  
    int a[] = { 33, 31, 40, 8, 12, 17, 25, 42 };  
    int n = sizeof(a) / sizeof(a[0]);  
    printf("Before sorting array elements are - \n");  
    printArr(a, n);  
    shell(a, n);  
    printf("\nAfter applying shell sort, the array elements are - \n");    
    printArr(a, n);  
    return 0;  
}  

Output:

The output of the following code will be -

Before sorting array elements are - 
33 31 40 8 12 17 25 42 
After applying shell sort, the array elements are - 
8 12 17 25 31 33 40 42

C++ Program:

 #include <iostream>  
using namespace std;   
int shell(int a[], int n)  
{  
    for (int interval = n/2; interval > 0; interval /= 2)  
    {  
        for (int i = interval; i < n; i += 1)  
        {  
            int temp = a[i];  
            int j;        
            for (j = i; j >= interval && a[j - interval] > temp; j -= interval)  
                a[j] = a[j - interval];  
              
            a[j] = temp;  
        }  
    }  
    return 0;  
}  
void printArr(int a[], int n)
{  
    int i;  
    for (i = 0; i < n; i++)  
        cout<<a[i]<<" ";  
}      
int main()  
{  
    int a[] = { 32, 30, 39, 7, 11, 16, 24, 41 };  
    int n = sizeof(a) / sizeof(a[0]);  
    cout << "Before sorting array elements are - \n";  
    printArr(a, n);  
    shell(a, n);  
    cout << "\nAfter applying shell sort, the array elements are - \n";    
    printArr(a, n);  
    return 0;  
}  

Output:

The output of the following code will be -

Before sorting array elements are - 
33 31 40 8 12 17 25 42 
After applying shell sort, the array elements are - 
8 12 17 25 31 33 40 42

Time Complexity:

Best Case: O(n*logn).
Average Case: O(n*log(n)²).
Worst Case: O(n²).

The shell sort has a space complexity of O(1).

Comb Sort vs. Shell Sort:

Comb Sort	Shell Sort
Comb Sort is a comparison sorting algorithm.	Shell Sort is an unreliable quadratic sorting algorithm.
Swap Sorts, such as the Bubble Sort and the Comb Sort, are very identical.	In such circumstances, this Sorting method is dependent on Insertion sort.
The Comb Sort is an expanded form of the Bubble Sort.	Shell sort refers to the generic Insertion Sort.
The comb sort introduces the gaps, which reflect the general separation between the two items.	The shell sort utilizes the "diminishing increment" technique.
The difference in a bubble sort possesses value of one and starts out huge.	This approach ensures that items with high and low values are rapidly relocated to the proper side of the array. Only items divided by a particular number are compared at each phase, so the first item is evaluated to the fifth element and the second element is compared to the sixth element.
After the traversal is completed, the value of the gap reduces until it reaches 1, where at time the comb sort algorithm basically degenerates into a bubble sort.	The gap value is set to 1 when the algorithm moves to a traditional insertion sort, which ends rapidly as there are now very few misplaced elements in the arrays.