Shell Sort:

In the realm of computer science, sorting algorithms play a pivotal role in organizing data efficiently. One such algorithm that stands out for its simplicity and effectiveness is the Shell Sort algorithm. Developed by Donald Shell in 1959, Shell Sort is an improvement over the Insertion Sort algorithm, offering better performance for larger datasets. This article aims to delve into the inner workings of Shell Sort, providing a comprehensive understanding of its steps, implementation, advantages, disadvantages, and complexities.

Steps of Shell Sort:

Shell Sort, also known as diminishing increment sort, works by sorting the elements at a specific interval rather than comparing adjacent elements. The algorithm follows these general steps:

Gap Sequence Determination: Define a sequence of gap values that dictate the intervals for comparing elements. Common sequences include the Knuth sequence (3x + 1) or Sedgewick sequence (4^k - 3 * 2^k + 1).

Sorting Phases: Start with the largest gap value and perform Insertion Sort on subarrays separated by this gap. Gradually reduce the gap value with each iteration until it becomes 1.

Final Pass: Perform a final pass with a gap value of 1, effectively sorting the entire array.

Shell sort example code

Here is a C source code of Bubble sorting with 5 integer elements. This code sorts the elements in ascending order.

#include <stdio.h>

void shellSort(int arr[], int n) {
    int gap, i, j, temp;
    for (gap = n / 2; gap > 0; gap /= 2) {
        for (= gap; i < n; i++) {
            temp = arr[i];
            for (= i; j >= gap && arr[- gap] > temp; j -= gap) {
                arr[j] = arr[- gap];
            arr[j] = temp;

int main() {
    int arr[] = {12, 34, 54, 2, 3};
    int n = sizeof(arr) / sizeof(arr[0]);
    shellSort(arr, n);
    printf("Sorted array: \n");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    return 0;


Efficient for medium-sized arrays.

Simple implementation with low overhead.

Adaptive to partially sorted arrays.

In-place sorting algorithm with relatively low memory usage.


Not as efficient as more advanced algorithms like Merge Sort or Quick Sort for larger datasets.

The performance heavily depends on the choice of gap sequence.

May not be stable in some implementations.

Not suitable for sorting linked lists due to its sequential nature.

Time Complexity:

The time complexity of Shell Sort depends on the choice of gap sequence. In the worst-case scenario, it is O(n^2), but with an optimal sequence, it can achieve O(n log n) or even better.

Space Complexity:

Shell Sort is an in-place sorting algorithm, so it has a space complexity of O(1).


Shell Sort, despite its age, remains a relevant and efficient sorting algorithm for many applications. Its simplicity, combined with moderate efficiency, makes it a valuable tool in the arsenal of any programmer. By understanding its inner workings and nuances, developers can leverage Shell Sort effectively to tackle sorting tasks efficiently.

Further readings

Types of sorting algoritms Selection Sort Insertion Sort Quick Sort Heap Sort Merge sort Radix Sort

  1. - bubble-sort
  2. - bubble-sort
  3. - bubble-sort
  4. - bubble-sort
  5. - bubble-sort

About our authors: Team EQA

You have viewed 1 page out of 252. Your C learning is 0.00% complete. Login to check your learning progress.