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

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 =
            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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right



Output:

 4 11 15 30 

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



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.





Article Tags :
Practice Tags :


7


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