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:

• 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
Recommended Articles
Page :