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

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

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

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

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

Javascript

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