Given a queue with random elements, we need to sort it. We are not allowed to use extra space. The operations allowed on queue are :
- enqueue() : Adds an item to rear of queue. In C++ STL queue, this function is called push().
- dequeue() : Removes an item from front of queue. In C++ STL queue, this function is called pop().
- isEmpty() : Checks if a queue is empty. In C++ STL queue, this function is called empty().
Examples :
Input : A queue with elements 11 5 4 21 Output : Modified queue with following elements 4 5 11 21 Input : A queue with elements 3 2 1 2 Output : Modified queue with following elements 1 2 2 3
If we are allowed extra space, then we can simply move all items of queue to an array, then sort the array and finally move array elements back to queue.
How to do without extra space?
The idea: on every pass on the queue, we seek for the next minimum index. To do this we dequeue and enqueue elements until we find the next minimum. In this operation the queue is not changed at all. After we have found the minimum index, we dequeue and enqueue elements from the queue except for the minimum index, after we finish the traversal in the queue we insert the minimum to the rear of the queue. We keep on this until all minimums are pushed all way long to the front and the queue becomes sorted.
On every next seeking for the minimum, we exclude seeking on the minimums that have already sorted.
We repeat this method n times.
At first we seek for the maximum, because on every pass we need find the next minimum, so we need to compare it with the largest element in the queue.
Illustration:
Input : ------------- 11 5 4 21 min index = 2 ------------- ------------- 11 5 21 4 after inserting 4 ------------- ------------- 11 5 21 4 min index = 1 ------------- ------------- 11 21 4 5 after inserting 5 ------------- ------------- 11 21 4 5 min index = 0 ------------- ------------- 21 4 5 11 after inserting 11 ------------- ------------- 21 4 5 11 min index = 0 ------------- ------------- 4 5 11 21 after inserting 21 ------------- Output : 4 5 11 21
// C++ program to implement sorting a // queue data structure #include <bits/stdc++.h> using namespace std;
// Queue elements after sortedIndex are // already sorted. This function returns // index of minimum element from front to // sortedIndex int minIndex(queue< int > &q, int sortedIndex)
{ int min_index = -1;
int min_val = INT_MAX;
int n = q.size();
for ( int i=0; i<n; i++)
{
int curr = q.front();
q.pop(); // This is dequeue() in C++ STL
// we add the condition i <= sortedIndex
// because we don't want to traverse
// on the sorted part of the queue,
// which is the right part.
if (curr <= min_val && i <= sortedIndex)
{
min_index = i;
min_val = curr;
}
q.push(curr); // This is enqueue() in
// C++ STL
}
return min_index;
} // Moves given minimum element to rear of // queue void insertMinToRear(queue< int > &q, int min_index)
{ int min_val;
int n = q.size();
for ( int i = 0; i < n; i++)
{
int curr = q.front();
q.pop();
if (i != min_index)
q.push(curr);
else
min_val = curr;
}
q.push(min_val);
} void sortQueue(queue< int > &q)
{ for ( int i = 1; i <= q.size(); i++)
{
int min_index = minIndex(q, q.size() - i);
insertMinToRear(q, min_index);
}
} // driver code int main()
{ queue< int > q;
q.push(30);
q.push(11);
q.push(15);
q.push(4);
// Sort queue
sortQueue(q);
// Print sorted queue
while (q.empty() == false )
{
cout << q.front() << " " ;
q.pop();
}
cout << endl;
return 0;
} |
// Java program to implement sorting a // queue data structure import java.util.LinkedList;
import java.util.Queue;
class GFG
{ // Queue elements after sortIndex are
// already sorted. This function returns
// index of minimum element from front to
// sortIndex
public static int minIndex(Queue<Integer> list,
int sortIndex)
{
int min_index = - 1 ;
int min_value = Integer.MAX_VALUE;
int s = list.size();
for ( int i = 0 ; i < s; i++)
{
int current = list.peek();
// This is dequeue() in Java STL
list.poll();
// we add the condition i <= sortIndex
// because we don't want to traverse
// on the sorted part of the queue,
// which is the right part.
if (current <= min_value && i <= sortIndex)
{
min_index = i;
min_value = current;
}
list.add(current);
}
return min_index;
} // Moves given minimum element
// to rear of queue
public static void insertMinToRear(Queue<Integer> list,
int min_index)
{
int min_value = 0 ;
int s = list.size();
for ( int i = 0 ; i < s; i++)
{
int current = list.peek();
list.poll();
if (i != min_index)
list.add(current);
else
min_value = current;
}
list.add(min_value);
}
public static void sortQueue(Queue<Integer> list)
{
for ( int i = 1 ; i <= list.size(); i++)
{
int min_index = minIndex(list,list.size() - i);
insertMinToRear(list, min_index);
}
}
//Driver function
public static void main (String[] args)
{
Queue<Integer> list = new LinkedList<Integer>();
list.add( 30 );
list.add( 11 );
list.add( 15 );
list.add( 4 );
//Sort Queue
sortQueue(list);
//print sorted Queue
while (list.isEmpty()== false )
{
System.out.print(list.peek() + " " );
list.poll();
}
}
} // This code is contributed by akash1295 |
# Python3 program to implement sorting a # queue data structure from queue import Queue
# Queue elements after sortedIndex are # already sorted. This function returns # index of minimum element from front to # sortedIndex def minIndex(q, sortedIndex):
min_index = - 1
min_val = 999999999999
n = q.qsize()
for i in range (n):
curr = q.queue[ 0 ]
q.get() # This is dequeue() in C++ STL
# we add the condition i <= sortedIndex
# because we don't want to traverse
# on the sorted part of the queue,
# which is the right part.
if (curr < = min_val and i < = sortedIndex):
min_index = i
min_val = curr
q.put(curr) # This is enqueue() in
# C++ STL
return min_index
# Moves given minimum element to # rear of queue def insertMinToRear(q, min_index):
min_val = None
n = q.qsize()
for i in range (n):
curr = q.queue[ 0 ]
q.get()
if (i ! = min_index):
q.put(curr)
else :
min_val = curr
q.put(min_val)
def sortQueue(q):
for i in range ( 1 , q.qsize() + 1 ):
min_index = minIndex(q, q.qsize() - i)
insertMinToRear(q, min_index)
# Driver code if __name__ = = '__main__' :
q = Queue()
q.put( 30 )
q.put( 11 )
q.put( 15 )
q.put( 4 )
# Sort queue
sortQueue(q)
# Print sorted queue
while (q.empty() = = False ):
print (q.queue[ 0 ], end = " " )
q.get()
# This code is contributed by PranchalK |
// C# program to implement // sorting a queue data structure using System;
using System.Collections.Generic;
class GFG
{ // Queue elements after sorted
// Index are already sorted.
// This function returns index
// of minimum element from front
// to sortedIndex
static int minIndex( ref Queue< int > q,
int sortedIndex)
{
int min_index = -1;
int min_val = int .MaxValue;
int n = q.Count;
for ( int i = 0; i < n; i++)
{
int curr = q.Peek();
q.Dequeue(); // This is dequeue()
// in C++ STL
// we add the condition
// i <= sortedIndex because
// we don't want to traverse
// on the sorted part of the
// queue, which is the right part.
if (curr <= min_val &&
i <= sortedIndex)
{
min_index = i;
min_val = curr;
}
q.Enqueue(curr); // This is enqueue()
// in C++ STL
}
return min_index;
}
// Moves given minimum
// element to rear of queue
static void insertMinToRear( ref Queue< int > q,
int min_index)
{
int min_val = 0;
int n = q.Count;
for ( int i = 0; i < n; i++)
{
int curr = q.Peek();
q.Dequeue();
if (i != min_index)
q.Enqueue(curr);
else
min_val = curr;
}
q.Enqueue(min_val);
}
static void sortQueue( ref Queue< int > q)
{
for ( int i = 1; i <= q.Count; i++)
{
int min_index = minIndex( ref q,
q.Count - i);
insertMinToRear( ref q,
min_index);
}
}
// Driver Code
static void Main()
{
Queue< int > q = new Queue< int >();
q.Enqueue(30);
q.Enqueue(11);
q.Enqueue(15);
q.Enqueue(4);
// Sort queue
sortQueue( ref q);
// Print sorted queue
while (q.Count != 0)
{
Console.Write(q.Peek() + " " );
q.Dequeue();
}
Console.WriteLine();
}
} // This code is contributed by // Manish Shaw(manishshaw1) |
<script> // / JavaScript program to implement sorting a // / queue data structure // / Queue elements after sortedIndex are // / already sorted. This function returns // / index of minimum element from front to // / sortedIndex function minIndex(q, sortedIndex)
{ let min_index = -1
let min_val = 999999999999
let n = q.length
for (let i = 0; i < n; i++)
{
let curr = q.shift()
// q.get() / This is dequeue() in C++ STL
// / we add the condition i <= sortedIndex
// / because we don't want to traverse
// / on the sorted part of the queue,
// / which is the right part.
if (curr <= min_val && i <= sortedIndex){
min_index = i
min_val = curr
}
q.push(curr) // This is enqueue() in
// / C++ STL
}
return min_index
} // / Moves given minimum element to // / rear of queue function insertMinToRear(q, min_index){
let min_val = 0
let n = q.length
for (let i=0;i<n;i++){
let curr = q.shift()
if (i != min_index)
q.push(curr)
else
min_val = curr
}
q.push(min_val)
} function sortQueue(q){
for (let i=1;i<q.length+1;i++){
let min_index = minIndex(q, q.length - i)
insertMinToRear(q, min_index)
}
} // / Driver code let q = [] q.push(30) q.push(11) q.push(15) q.push(4) // / Sort queue sortQueue(q) // / Print sorted queue while (q.length > 0){
document.write(q.shift(), " " )
} // This code is contributed by shinjanpatra </script> |
Output:
4 11 15 30
Time complexity of this algorithm is O(n^2).
Extra space needed is O(1).