# Sort a nearly sorted array using STL

Given an array of n elements, where each element is at most k away from its target position, devise an algorithm that sorts in O(n log k) time. For example, let us consider k is 2, an element at index 7 in the sorted array, can be at indexes 5, 6, 7, 8, 9 in the given array. It may be assumed that k < n.

Example:

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

Input: arr[] = {10, 9, 8, 7, 4, 70, 60, 50},
k = 4
Output: arr[] = {4, 7, 8, 9, 10, 50, 60, 70}
```

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Simple Approach: The basic solution is to sort the array using any standard sorting algorithm.

 `// A STL based C++ program to ` `// sort a nearly sorted array. ` `#include ` `using` `namespace` `std; ` ` `  `// Given an array of size n, ` `// where every element ` `// is k away from its target ` `// position, sorts the ` `// array in O(n Log n) time. ` `int` `sortK(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` `    ``// Sort the array using ` `    ``// inbuilt function ` `    ``sort(arr, arr + n); ` `} ` ` `  `// An utility function to print ` `// array elements ` `void` `printArray( ` `    ``int` `arr[], ``int` `size) ` `{ ` `    ``for` `(``int` `i = 0; i < size; i++) ` `        ``cout << arr[i] << ``" "``; ` `    ``cout << endl; ` `} ` ` `  `// Driver program to test ` `// above functions ` `int` `main() ` `{ ` `    ``int` `k = 3; ` `    ``int` `arr[] = { 2, 6, 3, 12, 56, 8 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``sortK(arr, n, k); ` ` `  `    ``cout << ``"Following is sorted array\n"``; ` `    ``printArray(arr, n); ` ` `  `    ``return` `0; ` `} `

Output:

```Following is sorted arrayn2 3 6 8 12 56
```

Complexity Analysis:

• Time complexity: O(n log n), where n is the size of the array.
The sorting algorithm takes log n time. Since the size of the array is n, the whole program takes O(n log n) time.
• Space Complxity: O(1).
As no extra space is required.

Efficient Solution: Sliding Window technique.
Approach: A better solution is to use a priority queue(or heap data structure). Use sliding window technique to keep consecutive k elements of a window in heap. Then remove the top element(smallest element) and replace the first element of the window with it.
As each element will be at most k distance apart, therefore keeping k consecutive elements in a window while replacing the i-th element with the smallest element from i to (i+k) will suffice(first i-1 elements are sorted).

Algorithm :

1. Build a priority queue pq of first (k+1) elements.
2. Initialize index = 0 (For result array).
3. Do following for elements from k+1 to n-1.
1. Pop an item from pq and put it at index, increment index.
2. Push arr[i] to pq.
4. While pq is not empty,
Pop an item from pq and put it at index, increment index.

We have discussed a simple implementation in Sort a nearly sorted (or K sorted) array. In this post, an STL based implementation is done.

 `// A STL based C++ program to sort ` `// a nearly sorted array. ` `#include ` `using` `namespace` `std; ` ` `  `// Given an array of size n, ` `// where every element ` `// is k away from its target ` `// position, sorts the ` `// array in O(nLogk) time. ` `int` `sortK(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` `    ``// Insert first k+1 items in a ` `    ``// priority queue (or min heap) ` `    ``// (A O(k) operation) ` `    ``priority_queue<``int``, vector<``int``>, ` `                   ``greater<``int``> > ` `        ``pq(arr, arr + k + 1); ` ` `  `    ``// i is index for remaining ` `    ``// elements in arr[] and index ` `    ``// is target index of for ` `    ``// current minimum element in ` `    ``// Min Heapm 'hp'. ` `    ``int` `index = 0; ` `    ``for` `(``int` `i = k + 1; i < n; i++) { ` `        ``arr[index++] = pq.top(); ` `        ``pq.pop(); ` `        ``pq.push(arr[i]); ` `    ``} ` ` `  `    ``while` `(pq.empty() == ``false``) { ` `        ``arr[index++] = pq.top(); ` `        ``pq.pop(); ` `    ``} ` `} ` ` `  `// A utility function to print ` `// array elements ` `void` `printArray(``int` `arr[], ``int` `size) ` `{ ` `    ``for` `(``int` `i = 0; i < size; i++) ` `        ``cout << arr[i] << ``" "``; ` `    ``cout << endl; ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` `    ``int` `k = 3; ` `    ``int` `arr[] = { 2, 6, 3, 12, 56, 8 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``sortK(arr, n, k); ` ` `  `    ``cout << ``"Following is sorted arrayn"``; ` `    ``printArray(arr, n); ` ` `  `    ``return` `0; ` `} `

Output:

```Following is sorted arrayn2 3 6 8 12 56
```

Complexity Analysis:

• Time Complexity: O(n Log k).
For every element, it is pushed in priority queue and the insertion and deletion needs O(log k) time as there are k elements in priority queue.
• Auxiliary Space : O(k).
To store k elements in priority queue, O(k) space is required.

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : andrew1234

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.