# ShellSort

ShellSort is mainly a variation of Insertion Sort. In insertion sort, we move elements only one position ahead. When an element has to be moved far ahead, many movements are involved. The idea of shellSort is to allow exchange of far items. In shellSort, we make the array h-sorted for a large value of h. We keep reducing the value of h until it becomes 1. An array is said to be h-sorted if all sublists of every h’th element is sorted.

Following is the implementation of ShellSort.

## C++

 `// C++ implementation of Shell Sort ` `#include  ` `using` `namespace` `std; ` ` `  `/* function to sort arr using shellSort */` `int` `shellSort(``int` `arr[], ``int` `n) ` `{ ` `    ``// Start with a big gap, then reduce the gap ` `    ``for` `(``int` `gap = n/2; gap > 0; gap /= 2) ` `    ``{ ` `        ``// Do a gapped insertion sort for this gap size. ` `        ``// The first gap elements a[0..gap-1] are already in gapped order ` `        ``// keep adding one more element until the entire array is ` `        ``// gap sorted  ` `        ``for` `(``int` `i = gap; i < n; i += 1) ` `        ``{ ` `            ``// add a[i] to the elements that have been gap sorted ` `            ``// save a[i] in temp and make a hole at position i ` `            ``int` `temp = arr[i]; ` ` `  `            ``// shift earlier gap-sorted elements up until the correct  ` `            ``// location for a[i] is found ` `            ``int` `j;             ` `            ``for` `(j = i; j >= gap && arr[j - gap] > temp; j -= gap) ` `                ``arr[j] = arr[j - gap]; ` `             `  `            ``//  put temp (the original a[i]) in its correct location ` `            ``arr[j] = temp; ` `        ``} ` `    ``} ` `    ``return` `0; ` `} ` ` `  `void` `printArray(``int` `arr[], ``int` `n) ` `{ ` `    ``for` `(``int` `i=0; i

## Java

 `// Java implementation of ShellSort ` `class` `ShellSort ` `{ ` `    ``/* An utility function to print array of size n*/` `    ``static` `void` `printArray(``int` `arr[]) ` `    ``{ ` `        ``int` `n = arr.length; ` `        ``for` `(``int` `i=``0``; i ``0``; gap /= ``2``) ` `        ``{ ` `            ``// Do a gapped insertion sort for this gap size. ` `            ``// The first gap elements a[0..gap-1] are already ` `            ``// in gapped order keep adding one more element ` `            ``// until the entire array is gap sorted ` `            ``for` `(``int` `i = gap; i < n; i += ``1``) ` `            ``{ ` `                ``// add a[i] to the elements that have been gap ` `                ``// sorted save a[i] in temp and make a hole at ` `                ``// position i ` `                ``int` `temp = arr[i]; ` ` `  `                ``// shift earlier gap-sorted elements up until ` `                ``// the correct location for a[i] is found ` `                ``int` `j; ` `                ``for` `(j = i; j >= gap && arr[j - gap] > temp; j -= gap) ` `                    ``arr[j] = arr[j - gap]; ` ` `  `                ``// put temp (the original a[i]) in its correct ` `                ``// location ` `                ``arr[j] = temp; ` `            ``} ` `        ``} ` `        ``return` `0``; ` `    ``} ` ` `  `    ``// Driver method ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `arr[] = {``12``, ``34``, ``54``, ``2``, ``3``}; ` `        ``System.out.println(``"Array before sorting"``); ` `        ``printArray(arr); ` ` `  `        ``ShellSort ob = ``new` `ShellSort(); ` `        ``ob.sort(arr); ` ` `  `        ``System.out.println(``"Array after sorting"``); ` `        ``printArray(arr); ` `    ``} ` `}  ` `/*This code is contributed by Rajat Mishra */`

## Python3

 `# Python3 program for implementation of Shell Sort ` ` `  `def` `shellSort(arr): ` ` `  `    ``# Start with a big gap, then reduce the gap ` `    ``n ``=` `len``(arr) ` `    ``gap ``=` `n``/``/``2` ` `  `    ``# Do a gapped insertion sort for this gap size. ` `    ``# The first gap elements a[0..gap-1] are already in gapped  ` `    ``# order keep adding one more element until the entire array ` `    ``# is gap sorted ` `    ``while` `gap > ``0``: ` ` `  `        ``for` `i ``in` `range``(gap,n): ` ` `  `            ``# add a[i] to the elements that have been gap sorted ` `            ``# save a[i] in temp and make a hole at position i ` `            ``temp ``=` `arr[i] ` ` `  `            ``# shift earlier gap-sorted elements up until the correct ` `            ``# location for a[i] is found ` `            ``j ``=` `i ` `            ``while`  `j >``=` `gap ``and` `arr[j``-``gap] >temp: ` `                ``arr[j] ``=` `arr[j``-``gap] ` `                ``j ``-``=` `gap ` ` `  `            ``# put temp (the original a[i]) in its correct location ` `            ``arr[j] ``=` `temp ` `        ``gap ``/``/``=` `2` ` `  ` `  `# Driver code to test above ` `arr ``=` `[ ``12``, ``34``, ``54``, ``2``, ``3``] ` ` `  `n ``=` `len``(arr) ` `print` `(``"Array before sorting:"``) ` `for` `i ``in` `range``(n): ` `    ``print``(arr[i]), ` ` `  `shellSort(arr) ` ` `  `print` `(``"\nArray after sorting:"``) ` `for` `i ``in` `range``(n): ` `    ``print``(arr[i]), ` ` `  `# This code is contributed by Mohit Kumra `

## C#

 `// C# implementation of ShellSort ` `using` `System; ` ` `  `class` `ShellSort ` `{ ` `    ``/* An utility function to  ` `       ``print array of size n*/` `    ``static` `void` `printArray(``int` `[]arr) ` `    ``{ ` `        ``int` `n = arr.Length; ` `        ``for` `(``int` `i=0; i 0; gap /= 2) ` `        ``{ ` `            ``// Do a gapped insertion sort for this gap size. ` `            ``// The first gap elements a[0..gap-1] are already ` `            ``// in gapped order keep adding one more element ` `            ``// until the entire array is gap sorted ` `            ``for` `(``int` `i = gap; i < n; i += 1) ` `            ``{ ` `                ``// add a[i] to the elements that have ` `                ``// been gap sorted save a[i] in temp and ` `                ``// make a hole at position i ` `                ``int` `temp = arr[i]; ` ` `  `                ``// shift earlier gap-sorted elements up until ` `                ``// the correct location for a[i] is found ` `                ``int` `j; ` `                ``for` `(j = i; j >= gap && arr[j - gap] > temp; j -= gap) ` `                    ``arr[j] = arr[j - gap]; ` ` `  `                ``// put temp (the original a[i])  ` `                ``// in its correct location ` `                ``arr[j] = temp; ` `            ``} ` `        ``} ` `        ``return` `0; ` `    ``} ` ` `  `    ``// Driver method ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[]arr = {12, 34, 54, 2, 3}; ` `        ``Console.Write(``"Array before sorting :\n"``); ` `        ``printArray(arr); ` ` `  `        ``ShellSort ob = ``new` `ShellSort(); ` `        ``ob.sort(arr); ` ` `  `        ``Console.Write(``"Array after sorting :\n"``); ` `        ``printArray(arr); ` `    ``} ` `}  ` ` `  `// This code is contributed by nitin mittal. `

Output:

```Array before sorting:
12 34 54 2 3
Array after sorting:
2 3 12 34 54```

Time Complexity: Time complexity of above implementation of shellsort is O(n2). In the above implementation gap is reduce by half in every iteration. There are many other ways to reduce gap which lead to better time complexity. See this for more details.

## Quiz on Shell Sort

Other Sorting Algorithms on GeeksforGeeks/GeeksQuiz:

• Selection Sort
• Bubble Sort
• Insertion Sort
• Merge Sort
• Heap Sort
• QuickSort
• Counting Sort
• Bucket Sort
•

## Coding practice for sorting.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

19

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.