In this data structure and algorithms tutorial, you will learn everything you need to know about the Shell Sort Algorithm.
Shell sort is a generalized version of the insertion sort algorithm. It first sorts elements that are far apart from each other and successively reduces the interval between the elements to be sorted.
The interval between the elements is reduced based on the sequence used. Some of the optimal sequences that can be used in the shell sort algorithm are:
N/2 , N/4 , …, 1
1, 4, 13, …, (3k
– 1) / 2
1, 8, 23, 77, 281, 1073, 4193, 16577...4j+1+ 3·2j+ 1
1, 3, 7, 15, 31, 63, 127, 255, 511…
1, 3, 5, 9, 17, 33, 65,...
1, 2, 3, 4, 6, 9, 8, 12, 18, 27, 16, 24, 36, 54, 81....
Note: The performance of the shell sort depends on the type of sequence used for a given input array.
(N/2, N/4, ...1
) as intervals in our algorithm.N = 8
then, the elements lying at the interval of N/2 = 4
are compared and swapped if they are not in order.temp
variable and the 0th
element (ie. greater element) is stored in the 4th
position and the element stored in temp
is stored in the 0th
position.N/4 = 8/4 = 2
is taken and again the elements lying at these intervals are sorted.2nd
position are compared. The elements at 2nd and 0th
position are also compared. All the elements in the array lying at the current interval are compared.N/8 = 8/8 =1
then the array elements lying at the interval of 1 are sorted. The array is now completely sorted.shellSort(array, size)
for interval i <- size/2n down to 1
for each interval "i" in array
sort all the elements at interval "i"
end shellSort
Python
# Shell sort in python
def shellSort(array, n):
# Rearrange elements at each n/2, n/4, n/8, ... intervals
interval = n // 2
while interval > 0:
for i in range(interval, n):
temp = array[i]
j = i
while j >= interval and array[j - interval] > temp:
array[j] = array[j - interval]
j -= interval
array[j] = temp
interval //= 2
data = [9, 8, 3, 7, 5, 6, 4, 1]
size = len(data)
shellSort(data, size)
print('Sorted Array in Ascending Order:')
print(data)
Java
// Shell sort in Java programming
import java.util.Arrays;
// Shell sort
class ShellSort {
// Rearrange elements at each n/2, n/4, n/8, ... intervals
void shellSort(int array[], int n) {
for (int interval = n / 2; interval > 0; interval /= 2) {
for (int i = interval; i < n; i += 1) {
int temp = array[i];
int j;
for (j = i; j >= interval && array[j - interval] > temp; j -= interval) {
array[j] = array[j - interval];
}
array[j] = temp;
}
}
}
// Driver code
public static void main(String args[]) {
int[] data = { 9, 8, 3, 7, 5, 6, 4, 1 };
int size = data.length;
ShellSort ss = new ShellSort();
ss.shellSort(data, size);
System.out.println("Sorted Array in Ascending Order: ");
System.out.println(Arrays.toString(data));
}
}
C programming
// Shell Sort in C programming
#include <stdio.h>
// Shell sort
void shellSort(int array[], int n) {
// Rearrange elements at each n/2, n/4, n/8, ... intervals
for (int interval = n / 2; interval > 0; interval /= 2) {
for (int i = interval; i < n; i += 1) {
int temp = array[i];
int j;
for (j = i; j >= interval && array[j - interval] > temp; j -= interval) {
array[j] = array[j - interval];
}
array[j] = temp;
}
}
}
// Print an array
void printArray(int array[], int size) {
for (int i = 0; i < size; ++i) {
printf("%d ", array[i]);
}
printf("\n");
}
// Driver code
int main() {
int data[] = {9, 8, 3, 7, 5, 6, 4, 1};
int size = sizeof(data) / sizeof(data[0]);
shellSort(data, size);
printf("Sorted array: \n");
printArray(data, size);
}
C++
// Shell Sort in C++ programming
#include <iostream>
using namespace std;
// Shell sort
void shellSort(int array[], int n) {
// Rearrange elements at each n/2, n/4, n/8, ... intervals
for (int interval = n / 2; interval > 0; interval /= 2) {
for (int i = interval; i < n; i += 1) {
int temp = array[i];
int j;
for (j = i; j >= interval && array[j - interval] > temp; j -= interval) {
array[j] = array[j - interval];
}
array[j] = temp;
}
}
}
// Print an array
void printArray(int array[], int size) {
int i;
for (i = 0; i < size; i++)
cout << array[i] << " ";
cout << endl;
}
// Driver code
int main() {
int data[] = {9, 8, 3, 7, 5, 6, 4, 1};
int size = sizeof(data) / sizeof(data[0]);
shellSort(data, size);
cout << "Sorted array: \n";
printArray(data, size);
}
Time Complexity | |
---|---|
Best | O(nlog n) |
Worst | O(n2) |
Average | O(nlog n) |
Space Complexity | O(1) |
Stability | No |
Shell sort is an unstable sorting algorithm because this algorithm does not examine the elements lying in between the intervals.
O(n2)
O(n2)
.Θ(Nlog N)2/(log log N)2)
or Θ(Nlog N)2/log log N)
or Θ(N(log N)2)
or something in between.O(n*log n)
O(n*log n)
O(n1.25)
.The complexity depends on the interval chosen. The above complexities differ for different increment sequences chosen. Best increment sequence is unknown.
The space complexity for shell sort is O(1)
.
Shell sort is used when:
uClibc
library uses this sort.bzip2
compressor uses it.#datastructures #algorithms