Stack Implementation using Deque

A doubly ended queue or deque allows insertion and deletion at both ends. In a stack, we need to do insertions and deletions at one end only. We can use either end of deque (front or back) to implement a stack,

In the below implementation, we use back (or rear) of stack to do both insertions and deletions. Please note that the time complexities of all the operations (insertions and deletions at both ends) in a deque is O(1). So the time complexity of the below implementation is O(1) only.

• In Java, the deque implementation of stack is preferred over standard Stack class, because the standard Stack class is legacy class and mainly designed for multi threaded environment.
• In Python, there is no standard stack class, so we can either use list or deque. The deque implementation is preferred because it is optimized for insertion and deletion at ends.

#include <iostream>
#include <deque>

using namespace std;

int main() {
    deque<int> stack;

    stack.push_back(10);
    stack.push_back(20);
    stack.push_back(30);

    cout << stack.back() << " popped from deque" << endl;
    stack.pop_back();
    cout << "Top element is: " << stack.back() << endl;
    return 0;
}

import java.util.*;

class GfG {
    public static void main(String[] args) {
        Deque<Integer> stack = new ArrayDeque<>();

        stack.push(10);
        stack.push(20);
        stack.push(30);

        System.out.println(stack.pop() + " popped from stack");
        System.out.println("Top element is: " + stack.peek());
    }
}

from collections import deque

stack = deque()

stack.append(10)
stack.append(20)
stack.append(30)

print(f'{stack.pop()} popped from stack')
print(f'Top element is: {stack[-1]}' if stack else 'Stack is empty')

30 popped from deque
Top element is: 20