Sort a nearly sorted array using STL
Last Updated :
24 Jan, 2023
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}
Simple Approach: The basic solution is to sort the array using any standard sorting algorithm.
Implementation:
CPP14
#include <bits/stdc++.h>
using namespace std;
int sortK( int arr[], int n, int k)
{
sort(arr, arr + n);
}
void printArray(
int arr[], int size)
{
for ( int i = 0; i < size; i++)
cout << arr[i] << " " ;
cout << endl;
}
int main()
{
int k = 3;
int arr[] = { 2, 6, 3, 12, 56, 8 };
int n = sizeof (arr) / sizeof (arr[0]);
sortK(arr, n, k);
cout << "Following is sorted array\n" ;
printArray(arr, n);
return 0;
}
|
Java
import java.util.*;
public class GFG
{
static void sortK( int [] arr, int n, int k)
{
Arrays.sort(arr);
}
static void printArray(
int [] arr, int size)
{
for ( int i = 0 ; i < size; i++)
System.out.print(arr[i] + " " );
System.out.println();
}
public static void main(String[] args)
{
int k = 3 ;
int [] arr = { 2 , 6 , 3 , 12 , 56 , 8 };
int n = arr.length;
sortK(arr, n, k);
System.out.println( "Following is sorted array" );
printArray(arr, n);
}
}
|
Python3
def sortK(arr, n, k):
arr.sort()
def printArray(arr, size):
for i in range (size):
print (arr[i], end = " " )
print ()
k = 3
arr = [ 2 , 6 , 3 , 12 , 56 , 8 ]
n = len (arr)
sortK(arr, n, k)
print ( "Following is sorted array" )
printArray(arr, n)
|
C#
using System;
class GFG
{
static void sortK( int [] arr, int n, int k)
{
Array.Sort(arr);
}
static void printArray(
int [] arr, int size)
{
for ( int i = 0; i < size; i++)
Console.Write(arr[i] + " " );
Console.WriteLine();
}
static void Main()
{
int k = 3;
int [] arr = { 2, 6, 3, 12, 56, 8 };
int n = arr.Length;
sortK(arr, n, k);
Console.WriteLine( "Following is sorted array" );
printArray(arr, n);
}
}
|
Javascript
<script>
function sortK(arr,n,k)
{
(arr).sort( function (a,b){ return a-b;});
}
function printArray(arr,size)
{
for (let i = 0; i < size; i++)
document.write(arr[i] + " " );
document.write( "<br>" );
}
let k = 3;
let arr=[ 2, 6, 3, 12, 56, 8 ];
let n = arr.length;
sortK(arr, n, k);
document.write( "Following is sorted array<br>" );
printArray(arr, n);
</script>
|
Output
Following is sorted array
2 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 Complexity: 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:
- Build a priority queue pq of first (k+1) elements.
- Initialize index = 0 (For result array).
- Do the following for elements from k+1 to n-1.
- Pop an item from pq and put it at index, increment index.
- Push arr[i] to pq.
- 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.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int sortK( int arr[], int n, int k)
{
priority_queue< int , vector< int >,
greater< int > >
pq(arr, arr + k + 1);
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();
}
}
void printArray( int arr[], int size)
{
for ( int i = 0; i < size; i++)
cout << arr[i] << " " ;
cout << endl;
}
int main()
{
int k = 3;
int arr[] = { 2, 6, 3, 12, 56, 8 };
int n = sizeof (arr) / sizeof (arr[0]);
sortK(arr, n, k);
cout << "Following is sorted arrayn" ;
printArray(arr, n);
return 0;
}
|
Java
import java.util.*;
public class SortK
{
public static int sortK( int arr[], int n, int k)
{
PriorityQueue<Integer> pq = new PriorityQueue<>();
for ( int i = 0 ; i < k + 1 ; i++)
pq.add(arr[i]);
int index = 0 ;
for ( int i = k + 1 ; i < n; i++) {
arr[index++] = pq.peek();
pq.poll();
pq.add(arr[i]);
}
while (!pq.isEmpty()) {
arr[index++] = pq.peek();
pq.poll();
}
return 0 ;
}
public static void printArray( int arr[], int size)
{
for ( int i = 0 ; i < size; i++)
System.out.print(arr[i] + " " );
System.out.println();
}
public static void main(String args[])
{
int k = 3 ;
int arr[] = { 2 , 6 , 3 , 12 , 56 , 8 };
int n = arr.length;
sortK(arr, n, k);
System.out.println( "Following is sorted array" );
printArray(arr, n);
}
}
|
Python
from heapq import heapify, heappop, heappush
def sortK(arr, n, k):
pq = arr[:k + 1 ]
heapify(pq)
index = 0
for i in range (k + 1 , n):
arr[index] = heappop(pq)
heappush(pq, arr[i])
index + = 1
while pq:
arr[index] = heappop(pq)
index + = 1
def printArray(arr, size):
for i in range (size):
print (arr[i])
k = 3
arr = [ 2 , 6 , 3 , 12 , 56 , 8 ]
n = len (arr)
sortK(arr, n, k)
print ( "Following is sorted array" )
printArray(arr, n)
|
Javascript
function sortK(arr, n, k) {
const pq = arr.slice(0, k + 1);
pq.sort((a, b) => a - b);
let index = 0;
for (let i = k + 1; i < n; i++) {
arr[index] = pq.shift();
pq.push(arr[i]);
pq.sort((a, b) => a - b);
index += 1;
}
while (pq.length > 0) {
arr[index] = pq.shift();
index += 1;
}
}
function printArray(arr) {
console.log(arr.join( ' ' ));
}
const k = 3;
const arr = [2, 6, 3, 12, 56, 8];
const n = arr.length;
sortK(arr, n, k);
console.log( 'Following is sorted array' );
printArray(arr);
|
C#
using System;
using System.Linq;
using System.Collections.Generic;
public class SortK {
public static void SortKMethod( int [] arr, int n, int k)
{
var pq = arr.Take(k + 1).ToList();
pq.Sort((a, b) = > a - b);
int index = 0;
for ( int i = k + 1; i < n; i++) {
arr[index] = pq[0];
pq.RemoveAt(0);
pq.Add(arr[i]);
pq.Sort((a, b) = > a - b);
index += 1;
}
while (pq.Count > 0) {
arr[index] = pq[0];
pq.RemoveAt(0);
index += 1;
}
}
public static void PrintArray( int [] arr)
{
Console.WriteLine( string .Join( " " , arr));
}
public static void Main()
{
int k = 3;
int [] arr = { 2, 6, 3, 12, 56, 8 };
int n = arr.Length;
SortKMethod(arr, n, k);
Console.WriteLine( "Following is sorted array" );
PrintArray(arr);
}
}
|
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 the 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 the priority queue, O(k) space is required.
Share your thoughts in the comments
Please Login to comment...