Skip to content
Related Articles
Sorting a Queue without extra space

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 :

1. enqueue() : Adds an item to rear of queue. In C++ STL queue, this function is called push().
2. dequeue() : Removes an item from front of queue. In C++ STL queue, this function is called pop().
3. 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```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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++

 `// C++ program to implement sorting a``// queue data structure``#include ``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 &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

 `// 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 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 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 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 list = ``new` `LinkedList();``        ``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

 `# 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) ``     ` `    ``# Prsorted queue ``    ``while` `(q.empty() ``=``=` `False``):``        ``print``(q.queue[``0``], end ``=` `" "``) ``        ``q.get()`` ` `# This code is contributed by PranchalK`

## C#

 `// 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)`

Output:
` 4 11 15 30 `

Time complexity of this algorithm is O(n^2).
Extra space needed is O(1).

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up