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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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 */



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# 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 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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. 



















                        chevron_right







                        filter_none










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.


References:

https://www.youtube.com/watch?v=pGhazjsFW28

http://en.wikipedia.org/wiki/Shellsort


 



Snapshots:

scene00721

scene00793

scene00937

scene01009

scene01801

scene02305


Quiz on Shell Sort


Other Sorting Algorithms on GeeksforGeeks/GeeksQuiz: