Sort the Queue using Recursion
Last Updated : 07 Mar, 2025
Given a queue, the task is to sort it using recursion without using any loop. We can only use the following functions of the queue:
- empty(q): Tests whether the queue is empty or not.
- push(q): Adds a new element to the queue.
- pop(q): Removes front element from the queue.
- size(q): Returns the number of elements in a queue.
- front(q): Returns the value of the front element without removing it.
Examples:
Input: queue = {10, 7, 16, 9, 20, 5}
Output: 5 7 9 10 16 20
Explanation : After sorting the elements of the Queue the order becomes 5 7 9 10 16 20
Input: queue = {0, -2, -1, 2, 3, 1}
Output: -2 -1 0 1 2 3
Explanation : After sorting the elements of the Queue the order becomes -2 -1 0 1 2 3.
Approach – O(n^2) Space and O(n) Time
- Take out the front item.
- Recursively sort the remaining queue (we mainly keep removing items recursively until the queue becomes empty)
- Sorted insert the front item in the remaining sorted queue (this is like insert of insertion sort). We use recursion for this also as we are supposed to use only recursion.
How to insert in sorted order using recursion?
- If queue is empty, we can simply insert and return.
- If the item (to be inserted) is smaller, then first insert at the back and then move all of previously existing elements to back. For example, q = [10, 20, 30] and temp = 5, we first insert 5, q = [10, 20, 30, 5], then move previously existing elements, q becomes [5, 10, 20, 30[
- If the item is more than the front, then we first move smaller elements to back and then we fall into the above case (element to be inserted is smaller). For example, q = [10, 20, 50] and temp = 40, we move all smaller elements back, q = [50, 10, 20], then we insert 40 using the above steps with smaller queue size which 1, we first get q = [50, 10, 20, 40], then q = [10, 20, 40, 50]
Illustration :
Step 1: Call sortQueue(q)
Queue at the start:
[10, 7, 16, 9, 20, 5]
- Remove
10, recursively sort [7, 16, 9, 20, 5]. - Remove
7, recursively sort [16, 9, 20, 5]. - Remove
16, recursively sort [9, 20, 5]. - Remove
9, recursively sort [20, 5]. - Remove
20, recursively sort [5].
Remove 5, recursively sort [] (Base case reached).
Step 2: Insert elements back using sortedInsert(q, temp, qsize)
Now we reinsert elements in sorted order.
- Insert
5 → [5] - Insert
20 → [5, 20] (Since 20 > 5, it goes to the back). - Insert
9:9 > 5, move 5 to back, q = [20, 5], and call sorted insert for [20, 5], 9 and qsize as 1.- 9 < 20, so 9 is first inserted at the back, q = [20, 5, 9] and then move qsize elements are moved front to back
- So q now becomes [5, 9, 20]
- Insert
16:16 > 5, move 5 to back, q = [9, 20, 5] and qsize = 216 > 9, move 9 to back, q = [20, 5, 9] and qsize = 116 < 20, insert 16, q = [20, 5, 9, 16] and move qsize elements back, So q = [5, 9, 16, 20]
- Insert
7:7 > 5, insert 7, move 5 to back, q = [9, 16, 20, 5] and call sorted insert with qsize as 37 < 9, insert 7, q = [9, 16, 20, 5, 7] and then move qsize elements to back- So q now becomes [5, 7, 9, 16, 20]
- Insert
10:10 > 5, move 5 to back, [7, 9, 16, 20, 5], qsize = 410 > 7, move 7 to back, [9, 16, 20, 5, 7], qsize = 3- 10 > 9, move 9 to back, [16, 20, 5, 7, 9], qsize = 2
- 10 < 16, insert 10, [16, 20, 5, 7, 9, 10], and move qsize elements to back
- So now q becomes [5, 7, 9, 10, 20]
C++ #include <bits/stdc++.h> using namespace std; // One by one moves qsize elements from front // to rear of the queue. void frontToEndN(queue<int>& q, int qsize) { if (qsize <= 0) return; // pop front element and push // this last in a queue q.push(q.front()); q.pop(); // Recursive call for pushing element frontToEndN(q, qsize - 1); } // Function to push an element in the queue with qsize void sortedInsert(queue<int>& q, int temp, int qsize) { // Base condition if (q.empty() || qsize == 0) { q.push(temp); return; } else if (temp <= q.front()) { // Call stack with front of queue q.push(temp); // One by one move n-1 (old q size // elements front to back frontToEndN(q, qsize); } else { // Push front element into // last in a queue q.push(q.front()); q.pop(); // Recursively move all smaller // items to back and then insert sortedInsert(q, temp, qsize - 1); } } // Function to sort the given // queue using recursion void sortQueue(queue<int>& q) { if (q.empty()) return; // Get the front element which will // be stored in this variable // throughout the recursion stack int temp = q.front(); q.pop(); sortQueue(q); // Push the current element into the queue // according to the sorting order sortedInsert(q, temp, q.size()); } int main() { queue<int> qu; qu.push(10); qu.push(7); qu.push(16); qu.push(9); qu.push(20); qu.push(5); sortQueue(qu); while (!qu.empty()) { cout << qu.front() << " "; qu.pop(); } } // One by one moves qsize elements from front // to rear of the queue. import java.util.LinkedList; import java.util.Queue; public class GfG { // One by one moves qsize elements from front to rear of the queue. static void frontToEndN(Queue<Integer> q, int qsize) { if (qsize <= 0) return; // pop front element and push this last in a queue q.add(q.poll()); // Recursive call for pushing element frontToEndN(q, qsize - 1); } // Function to push an element in the queue with qsize static void sortedInsert(Queue<Integer> q, int temp, int qsize) { // Base condition if (q.isEmpty() || qsize == 0) { q.add(temp); return; } else if (temp <= q.peek()) { // Call stack with front of queue q.add(temp); // One by one move n-1 (old q size elements front to back frontToEndN(q, qsize); } else { // Push front element into last in a queue q.add(q.poll()); // Recursively move all smaller items to back and then insert sortedInsert(q, temp, qsize - 1); } } // Function to sort the given queue using recursion static void sortQueue(Queue<Integer> q) { if (q.isEmpty()) return; // Get the front element which will be stored in this variable // throughout the recursion stack int temp = q.poll(); sortQueue(q); // Push the current element into the queue according to the sorting order sortedInsert(q, temp, q.size()); } public static void main(String[] args) { Queue<Integer> qu = new LinkedList<>(); qu.add(10); qu.add(7); qu.add(16); qu.add(9); qu.add(20); qu.add(5); sortQueue(qu); while (!qu.isEmpty()) { System.out.print(qu.poll() + " "); } } } # One by one moves qsize elements from front # to rear of the queue. def front_to_end_n(q, qsize): if qsize <= 0: return # pop front element and push # this last in a queue q.append(q.pop(0)) # Recursive call for pushing element front_to_end_n(q, qsize - 1) # Function to push an element in the queue with qsize def sorted_insert(q, temp, qsize): # Base condition if not q or qsize == 0: q.append(temp) return elif temp <= q[0]: # Call stack with front of queue q.append(temp) # One by one move n-1 (old q size elements front to back front_to_end_n(q, qsize) else: # Push front element into last in a queue q.append(q.pop(0)) # Recursively move all smaller items to back and then insert sorted_insert(q, temp, qsize - 1) # Function to sort the given queue using recursion def sort_queue(q): if not q: return # Get the front element which will # be stored in this variable # throughout the recursion stack temp = q.pop(0) sort_queue(q) # Push the current element into the queue # according to the sorting order sorted_insert(q, temp, len(q)) if __name__ == '__main__': qu = [] qu.append(10) qu.append(7) qu.append(16) qu.append(9) qu.append(20) qu.append(5) sort_queue(qu) while qu: print(qu.pop(0), end=' ')
// One by one moves qsize elements from front // to rear of the queue. using System; using System.Collections.Generic; class GfG { // One by one moves qsize elements from front to rear of the queue. static void FrontToEndN(Queue<int> q, int qsize) { if (qsize <= 0) return; // pop front element and push this last in a queue q.Enqueue(q.Dequeue()); // Recursive call for pushing element FrontToEndN(q, qsize - 1); } // Function to push an element in the queue with qsize static void SortedInsert(Queue<int> q, int temp, int qsize) { // Base condition if (q.Count == 0 || qsize == 0) { q.Enqueue(temp); return; } else if (temp <= q.Peek()) { // Call stack with front of queue q.Enqueue(temp); // One by one move n-1 (old q size elements front to back FrontToEndN(q, qsize); } else { // Push front element into last in a queue q.Enqueue(q.Dequeue()); // Recursively move all smaller items to back and then insert SortedInsert(q, temp, qsize - 1); } } // Function to sort the given queue using recursion static void SortQueue(Queue<int> q) { if (q.Count == 0) return; // Get the front element which will be stored in this variable // throughout the recursion stack int temp = q.Dequeue(); SortQueue(q); // Push the current element into the queue according to the sorting order SortedInsert(q, temp, q.Count); } public static void Main(string[] args) { Queue<int> qu = new Queue<int>(); qu.Enqueue(10); qu.Enqueue(7); qu.Enqueue(16); qu.Enqueue(9); qu.Enqueue(20); qu.Enqueue(5); SortQueue(qu); while (qu.Count > 0) { Console.Write(qu.Dequeue() + " "); } } } // One by one moves qsize elements from front // to rear of the queue. function frontToEndN(q, qsize) { if (qsize <= 0) { return; } // pop front element and push // this last in a queue q.push(q.shift()); // Recursive call for pushing element frontToEndN(q, qsize - 1); } // Function to push an element in the queue with qsize function sortedInsert(q, temp, qsize) { // Base condition if (q.length === 0 || qsize === 0) { q.push(temp); return; } else if (temp <= q[0]) { // Call stack with front of queue q.push(temp); // One by one move n-1 (old q size elements front to back frontToEndN(q, qsize); } else { // Push front element into last in a queue q.push(q.shift()); // Recursively move all smaller items to back and then insert sortedInsert(q, temp, qsize - 1); } } // Function to sort the given queue using recursion function sortQueue(q) { if (q.length === 0) { return; } // Get the front element which will // be stored in this variable // throughout the recursion stack let temp = q.shift(); sortQueue(q); // Push the current element into the queue // according to the sorting order sortedInsert(q, temp, q.length); } // Example usage let qu = []; qu.push(10); qu.push(7); qu.push(16); qu.push(9); qu.push(20); qu.push(5); sortQueue(qu); while (qu.length > 0) { process.stdout.write(qu.shift() + ' '); } Time Complexity: The time complexity of this code is O(n^2), as the time taken to sort the queue is O(n^2) due to the use of recursion. The function pushInQueue() is called n times, and each time it calls the function FrontToLast() which takes O(n) time, resulting in a time complexity of O(n^2).
Auxiliary Space: The Auxiliary Space of this code is O(n), as the maximum size of the queue will be n, where n is the number of elements in the queue.