# Sort a nearly sorted (or K sorted) array | Set 2 (Gap method – Shell sort)

• Last Updated : 03 Sep, 2021

Given an array, arr[] of N elements, where each element is at most K away from its target position, the task is to devise an algorithm that sorts in O(N*log(K)) time.

Examples:

Input: arr[] = {10, 9, 8, 7, 4, 70, 60, 50}, K = 4
Output: 4 7 8 9 10 50 60 70
Explanation:
Follow the steps below to sort the array:

1. Start with Gap = K(i.e. 4)
• 10 9 8 7 4 70 60 50, swap the elements at indices 0 and 4. Then the array modifies to {4, 9, 8, 7, 10, 70, 60, 50}.
4 9 8 7 10 70 60 50, Do not swap the elements at indices 1 and 5.
4 9 8 7 10 70 60 50, Do not swap the elements at indices 2 and 6.
4 9 8 7 10 70 60 50, Do not swap the elements at indices 3 and 7.
2. Gap = ceiling of 4/2 = 2
• 4 9 8 7 10 70 60 50, Do not swap the elements at indices 0 and 2.
4 9 8 7 10 70 60 50, swap the elements at indices 1 and 3. Then the array modifies to {4, 7, 8, 9, 10, 70, 60, 50}.
4 7 8 9 10 70 60 50, Do not swap the elements at indices 2 and 4.
4 7 8 9 10 70 60 50, Do not swap the elements at indices 3 and 5.
4 7 8 9 10 70 60 50, Do not swap the elements at indices 4 and 6.
4 7 8 9 10 70 60 50, swap the elements at indices 5 and 7. Then the array modifies to {4, 7, 8, 9, 10, 70, 60, 50}.
4 7 8 9 10 50 60 70
3. Gap = ceiling of 2/2 = 1
• 4 7 8 9 10 50 60 70, Do not swap the elements at indices 0 and 1.
4 7 8 9 10 50 60 70, Do not swap the elements at indices 1 and 2.
4 7 8 9 10 50 60 70, Do not swap the elements at indices 2 and 3.
4 7 8 9 10 50 60 70, Do not swap the elements at indices 3 and 4.
4 7 8 9 10 50 60 70, Do not swap the elements at indices 4 and 5.
4 7 8 9 10 50 60 70, Do not swap the elements at indices 5 and 6.
4 7 8 9 10 50 60 70, Do not swap the elements at indices 6 and 7.

Input: arr[] = {6, 5, 3, 2, 8, 10, 9}, K = 3
Output: 2 3 5 6 8 9 10

Approach: The given problem Sort a nearly sorted (or K sorted) array is already solved. Here the idea is to use shell sorting to sort the array. The idea used here is similar to the merging step of the In-Place Merge Sort. Follow the steps below to solve the problem:

• Initialize a variable, say Gap with a value K to sort every Gapth element of every sublist.
• Iterate until Gap is greater than 0 and perform the following steps:
• Iterate over the range [0, N-Gap] using the variable i, and in each iteration, if arr[i] is greater than the arr[i+Gap], then swap the array elements.
• Update the Gap as Gap = ceil(Gap/2).
• Finally, after completing the above step print the elements of the array arr[].

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the nextGap``int` `nextGap(``double` `k)``{``    ``if` `(k < 2)``        ``return` `0;``    ``return` `ceil``(k / 2);``}` `// A utility function to print the array``void` `printArray(``int` `arr[], ``int` `n)``{``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << arr[i] << ``" "``;``}``// Function to sort a K sorted array``void` `kSort(``int` `arr[], ``int` `K, ``int` `n)``{``  ` `    ``// Iterate until gap is atleast``    ``// greater than 0``    ``for` `(``int` `gap = K; gap > 0; gap = nextGap(gap)) {` `        ``// Iterate over the range [0, N]``        ``for` `(``int` `i = 0; i + gap < n; i++) {` `            ``// If arr[i] is greater``            ``// than arr[i+gap]``            ``if` `(arr[i] > arr[i + gap]) {` `                ``// Swap arr[i] and``                ``// arr[i+gap]``                ``swap(arr[i], arr[i + gap]);``            ``}``        ``}``    ``}``    ``printArray(arr, n);``}` `// Driver Code``int` `main()``{` `    ``// Input``    ``int` `arr[] = { 10, 9, 8, 7, 4, 70, 60, 50 };``    ``int` `K = 3;``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``  ` `    ``// Function call``    ``kSort(arr, K, n);``    ``return` `0;``}` `// This code is contributed by lokesh potta.`

## Java

 `// Java program for the above approach``import` `java.util.Iterator;``import` `java.util.PriorityQueue;` `class` `GFG {` `    ``// Function to sort a K sorted array``    ``static` `void` `kSort(``int``[] arr, ``int` `K)``    ``{``        ``// Iterate until gap is atleast``        ``// greater than 0``        ``for` `(``int` `gap = K; gap > ``0``; gap = nextGap(gap)) {` `            ``// Iterate over the range [0, N]``            ``for` `(``int` `i = ``0``; i + gap < arr.length; i++) {` `                ``// If arr[i] is greater``                ``// than arr[i+gap]``                ``if` `(arr[i] > arr[i + gap]) {` `                    ``// Swap arr[i] and``                    ``// arr[i+gap]``                    ``swap(arr, i, i + gap);``                ``}``            ``}``        ``}``        ``printArray(arr);``    ``}` `    ``// Function to find the nextGap``    ``static` `int` `nextGap(``double` `k)``    ``{``        ``if` `(k < ``2``)``            ``return` `0``;``        ``return` `(``int``)Math.ceil(k / ``2``);``    ``}` `    ``// Function to swap two elements``    ``// of the array arr[]``    ``static` `void` `swap(``int``[] arr, ``int` `i, ``int` `j)``    ``{``        ``int` `temp = arr[i];``        ``arr[i] = arr[j];``        ``arr[j] = temp;``    ``}` `    ``// A utility function to print the array``    ``private` `static` `void` `printArray(``int``[] arr)``    ``{``        ``for` `(``int` `i = ``0``; i < arr.length; i++)``            ``System.out.print(arr[i] + ``" "``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Input``        ``int` `arr[] = { ``10``, ``9``, ``8``, ``7``, ``4``, ``70``, ``60``, ``50` `};``        ``int` `K = ``3``;` `        ``// Function call``        ``kSort(arr, K);``    ``}``}`

## Python3

 `# Python3 program for the above approach``import` `math` `# Function to find the nextGap``def` `nextGap(k):``    ` `    ``if` `(k < ``2``):``        ``return` `0``        ` `    ``return` `math.ceil(k ``/` `2``)` `# A utility function to print array``def` `printArray(arr, n):``    ` `    ``for` `i ``in` `range``(n):``        ``print``(arr[i], end ``=` `" "``)` `# Function to sort a K sorted array``def` `kSort(arr, K, n):``  ` `    ``# Iterate until gap is atleast``    ``# greater than 0``    ``gap ``=` `K``    ` `    ``while` `(gap > ``0``):``        ` `        ``# Iterate over the range [0, N]``        ``i ``=` `0``        ``while` `(i ``+` `gap < n):``            ` `            ``# If arr[i] is greater``            ``# than arr[i+gap]``            ``if` `(arr[i] > arr[i ``+` `gap]):``                ` `                ``# Swap arr[i] and``                ``# arr[i+gap]``                ``arr[i], arr[i ``+` `gap] ``=` `arr[i ``+` `gap], arr[i]``                ` `            ``i ``+``=` `1``        ` `        ``gap ``=` `nextGap(gap)``        ` `    ``printArray(arr, n)` `# Driver Code` `# Input``arr ``=` `[ ``10``, ``9``, ``8``, ``7``, ``4``, ``70``, ``60``, ``50` `]``K ``=` `3``n ``=` `len``(arr)``  ` `# Function call``kSort(arr, K, n)` `# This code is contributed by target_2`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG {` `    ``// Function to sort a K sorted array``    ``static` `void` `kSort(``int``[] arr, ``int` `K)``    ``{``        ``// Iterate until gap is atleast``        ``// greater than 0``        ``for` `(``int` `gap = K; gap > 0; gap = nextGap(gap)) {` `            ``// Iterate over the range [0, N]``            ``for` `(``int` `i = 0; i + gap < arr.Length; i++) {` `                ``// If arr[i] is greater``                ``// than arr[i+gap]``                ``if` `(arr[i] > arr[i + gap]) {` `                    ``// Swap arr[i] and``                    ``// arr[i+gap]``                    ``swap(arr, i, i + gap);``                ``}``            ``}``        ``}``        ``printArray(arr);``    ``}` `    ``// Function to find the nextGap``    ``static` `int` `nextGap(``double` `k)``    ``{``        ``if` `(k < 2)``            ``return` `0;``        ``return` `(``int``)Math.Ceiling(k / 2);``    ``}` `    ``// Function to swap two elements``    ``// of the array arr[]``    ``static` `void` `swap(``int``[] arr, ``int` `i, ``int` `j)``    ``{``        ``int` `temp = arr[i];``        ``arr[i] = arr[j];``        ``arr[j] = temp;``    ``}` `    ``// A utility function to print the array``    ``private` `static` `void` `printArray(``int``[] arr)``    ``{``        ``for` `(``int` `i = 0; i < arr.Length; i++)``            ``Console.Write(arr[i] + ``" "``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``// Input``        ``int` `[]arr = { 10, 9, 8, 7, 4, 70, 60, 50 };``        ``int` `K = 3;` `        ``// Function call``        ``kSort(arr, K);``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``

Output

`4 7 8 9 10 50 60 70 `

Time Complexity: O(N*log K)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up