# Implement a stack using single queue

We are given queue data structure, the task is to implement stack using only given queue data structure.
We have discussed a solution that uses two queues. In this article, a new solution is discussed that uses only one queue. This solution assumes that we can find size of queue at any point. The idea is to keep newly inserted element always at front of queue, keeping order of previous elements same.

Below are complete steps.

```// x is the element to be pushed and s is stack
push(s, x)
1) Let size of q be s.
1) Enqueue x to q
2) One by one Dequeue s items from queue and enqueue them.

// Removes an item from stack
pop(s)
1) Dequeue an item from q```

Below is implementation of the idea.

## C++

 `// C++ program to implement a stack using` `// single queue` `#include` `using` `namespace` `std;`   `// User defined stack that uses a queue` `class` `Stack` `{` `    ``queue<``int``>q;` `public``:` `    ``void` `push(``int` `val);` `    ``void` `pop();` `    ``int` `top();` `    ``bool` `empty();` `};`   `// Push operation` `void` `Stack::push(``int` `val)` `{` `    ``//  Get previous size of queue` `    ``int` `s = q.size();`   `    ``// Push current element` `    ``q.push(val);`   `    ``// Pop (or Dequeue) all previous` `    ``// elements and put them after current` `    ``// element` `    ``for` `(``int` `i=0; i

## Java

 `// Java program to implement stack using a ` `// single queue`   `import` `java.util.LinkedList;` `import` `java.util.Queue;`   `public` `class` `stack ` `{` `    ``Queue q = ``new` `LinkedList();` `    `  `    ``// Push operation` `    ``void` `push(``int` `val) ` `    ``{` `        ``// get previous size of queue` `        ``int` `size = q.size();` `        `  `        ``// Add current element` `        ``q.add(val);` `        `  `        ``// Pop (or Dequeue) all previous` `        ``// elements and put them after current` `        ``// element` `        ``for` `(``int` `i = ``0``; i < size; i++) ` `        ``{` `            ``// this will add front element into` `            ``// rear of queue` `            ``int` `x = q.remove();` `            ``q.add(x);` `        ``}` `    ``}` `    `  `    ``// Removes the top element` `    ``int` `pop() ` `    ``{` `        ``if` `(q.isEmpty()) ` `        ``{` `            ``System.out.println(``"No elements"``);` `            ``return` `-``1``;` `        ``}` `        ``int` `x = q.remove();` `        ``return` `x;` `    ``}` `    `  `    ``// Returns top of stack` `    ``int` `top() ` `    ``{` `        ``if` `(q.isEmpty())` `            ``return` `-``1``;` `        ``return` `q.peek();` `    ``}` `    `  `    ``// Returns true if Stack is empty else false` `    ``boolean` `isEmpty() ` `    ``{` `        ``return` `q.isEmpty();` `    ``}`   `    ``// Driver program to test above methods` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``stack s = ``new` `stack();` `        ``s.push(``10``);` `        ``s.push(``20``);` `        ``System.out.println(``"Top element :"` `+ s.top());` `        ``s.pop();` `        ``s.push(``30``);` `        ``s.pop();` `        ``System.out.println(``"Top element :"` `+ s.top());` `    ``}` `}`   `// This code is contributed by Rishabh Mahrsee`

## Python3

 `# Python3 program to implement stack using a ` `# single queue ` ` `  `q ``=` `[]`   `# append operation ` `def` `append(val):`   `    ``# get previous size of queue ` `    ``size ``=` `len``(q)`   `    ``# Add current element ` `    ``q.append(val); `   `    ``# Pop (or Dequeue) all previous ` `    ``# elements and put them after current` `    ``# element` `    ``for` `i ``in` `range``(size):`   `        ``# this will add front element into ` `        ``# rear of queue ` `        ``x ``=` `q.pop(``0``); ` `        ``q.append(x); ` `           `  `# Removes the top element ` `def` `pop():`   `    ``if` `(``len``(q) ``=``=` `0``):`   `        ``print``(``"No elements"``); ` `        ``return` `-``1``; ` `    `  `    ``x ``=` `q.pop(``0``); ` `    ``return` `x; `   `# Returns top of stack ` `def` `top():`   `    ``if``(``len``(q) ``=``=` `0``):` `        ``return` `-``1``; ` `    ``return` `q[``-``1``]`   `# Returns true if Stack is empty else false ` `def` `isEmpty():`   `    ``return` `len``(q)``=``=``0``; `   `# Driver program to test above methods ` `if` `__name__``=``=``'__main__'``:`   `    ``s ``=` `[]`   `    ``s.append(``10``); ` `    ``s.append(``20``); ` `    ``print``(``"Top element :"` `+` `str``(s[``-``1``])); ` `    ``s.pop(); ` `    ``s.append(``30``); ` `    ``s.pop(); ` `    ``print``(``"Top element :"` `+` `str``(s[``-``1``]));` `    `  `    ``# This code is contributed by rutvik_56.`

## C#

 `// C# program to implement stack using a ` `// single queue` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `stack ` `{` `    ``Queue<``int``> q = ``new` `Queue<``int``>();` `    `  `    ``// Push operation` `    ``void` `push(``int` `val) ` `    ``{` `        ``// get previous size of queue` `        ``int` `size = q.Count;` `        `  `        ``// Add current element` `        ``q.Enqueue(val);` `        `  `        ``// Pop (or Dequeue) all previous` `        ``// elements and put them after current` `        ``// element` `        ``for` `(``int` `i = 0; i < size; i++) ` `        ``{` `            ``// this will add front element into` `            ``// rear of queue` `            ``int` `x = q.Dequeue();` `            ``q.Enqueue(x);` `        ``}` `    ``}` `    `  `    ``// Removes the top element` `    ``int` `pop() ` `    ``{` `        ``if` `(q.Count == 0) ` `        ``{` `            ``Console.WriteLine(``"No elements"``);` `            ``return` `-1;` `        ``}` `        ``int` `x = q.Dequeue();` `        ``return` `x;` `    ``}` `    `  `    ``// Returns top of stack` `    ``int` `top() ` `    ``{` `        ``if` `(q.Count == 0)` `            ``return` `-1;` `        ``return` `q.Peek();` `    ``}` `    `  `    ``// Returns true if Stack is empty else false` `    ``bool` `isEmpty() ` `    ``{` `        ``if``(q.Count == 0)` `            ``return` `true``;` `        ``return` `false``;` `    ``}`   `    ``// Driver program to test above methods` `    ``public` `static` `void` `Main(String[] args) ` `    ``{` `        ``stack s = ``new` `stack();` `        ``s.push(10);` `        ``s.push(20);` `        ``Console.WriteLine(``"Top element :"` `+ s.top());` `        ``s.pop();` `        ``s.push(30);` `        ``s.pop();` `        ``Console.WriteLine(``"Top element :"` `+ s.top());` `    ``}` `}`   `// This code has been contributed by Rajput-Ji `

## Javascript

 ``

Output

```20
10```

Time complexity: O(N) where N is size of stack

Auxiliary Space: O(N)

If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next