Quiz on Shell Sort
Other Sorting Algorithms on w3wiki/GeeksQuiz:
ShellSort
Shell sort 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 the exchange of far items. In Shell sort, 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 are sorted.
Algorithm:
Step 1 − Start
Step 2 − Initialize the value of gap size, say h.
Step 3 − Divide the list into smaller sub-part. Each must have equal intervals to h.
Step 4 − Sort these sub-lists using insertion sort.
Step 5 – Repeat this step 2 until the list is sorted.
Step 6 – Print a sorted list.
Step 7 – Stop.
Following is the implementation of ShellSort.
C++
// C++ implementation of Shell Sort #include <iostream> 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<n; i++) cout << arr[i] << " " ; } int main() { int arr[] = {12, 34, 54, 2, 3}, i; int n = sizeof (arr)/ sizeof (arr[0]); cout << "Array before sorting: \n" ; printArray(arr, n); shellSort(arr, n); cout << "\nArray after sorting: \n" ; printArray(arr, n); return 0; } |
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<n; ++i) System.out.print(arr[i] + " " ); System.out.println(); } /* function to sort arr using shellSort */ int sort( int arr[]) { int n = arr.length; // 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 ; } // 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 */ |
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<n; ++i) Console.Write(arr[i] + " " ); Console.WriteLine(); } /* function to sort arr using shellSort */ int sort( int []arr) { int n = arr.Length; // 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; } // 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. |
Javascript
<script> // Javascript implementation of ShellSort /* An utility function to print array of size n*/ function printArray(arr) { let n = arr.length; for (let i = 0; i < n; ++i) document.write(arr[i] + " " ); document.write( "<br>" ); } /* function to sort arr using shellSort */ function sort(arr) { let n = arr.length; // Start with a big gap, then reduce the gap for (let gap = Math.floor(n/2); gap > 0; gap = Math.floor(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 (let 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 let temp = arr[i]; // shift earlier gap-sorted elements up until // the correct location for a[i] is found let 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 arr; } // Driver method let arr = [12, 34, 54, 2, 3]; document.write( "Array before sorting<br>" ); printArray(arr); arr = sort(arr); document.write( "Array after sorting<br>" ); printArray(arr); // This code is contributed by unknown2108 </script> |
Python3
# Python3 program for implementation of Shell Sort # Python3 program for implementation of Shell Sort def shellSort(arr, n): # code here gap = n / / 2 while gap> 0 : j = gap # Check the array in from left to right # Till the last possible index of j while j<n: i = j - gap # This will keep help in maintain gap value while i> = 0 : # If value on right side is already greater than left side value # We don't do swap else we swap if arr[i + gap]>arr[i]: break else : arr[i + gap],arr[i] = arr[i],arr[i + gap] i = i - gap # To check left side also # If the element present is greater than current element j + = 1 gap = gap / / 2 # driver to check the code arr2 = [ 12 , 34 , 54 , 2 , 3 ] print ( "input array:" ,arr2) shellSort(arr2, len (arr2)) print ( "sorted array" ,arr2) # This code is contributed by Illion |
Array before sorting: 12 34 54 2 3 Array after sorting: 2 3 12 34 54
Time Complexity: Time complexity of the above implementation of Shell sort is O(n2). In the above implementation, the gap is reduced by half in every iteration. There are many other ways to reduce gaps which leads to better time complexity. See this for more details.
Worst Case Complexity
The worst-case complexity for shell sort is O(n2)
Best Case Complexity
When the given array list is already sorted the total count of comparisons of each interval is equal to the size of the given array.
So best case complexity is Ω(n log(n))
Average Case Complexity
The Average Case Complexity: O(n*log n)~O(n1.25)
Space Complexity
The space complexity of the shell sort is O(1).