Print Stack Elements from Top to Bottom

19 Jan, 2022
Given a Stack S, the task is to print the elements of the stack from top to bottom such that the elements are still present in the stack without their order being changed.
Examples:
Input: S = {2, 3, 4, 5}Output: 5 4 3 2
Input: S = {3, 3, 2, 2}Output: 2 2 3 3
Recursive Approach: Follow the steps below to solve the problem:
Create a recursive function having stack as the parameter.Add the base condition that, if the stack is empty, return from the function.Otherwise, store the top element in some variable X and remove it.Print X, call the recursive function and pass the same stack in it.Push the stored X back to the Stack.
Create a recursive function having stack as the parameter.
Add the base condition that, if the stack is empty, return from the function.
Otherwise, store the top element in some variable X and remove it.
Print X, call the recursive function and pass the same stack in it.
Push the stored X back to the Stack.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Function to print stack elements// from top to bottom with the// order of elements unalteredvoid PrintStack(stack<int> s){    // If stack is empty    if (s.empty())        return; // Extract top of the stack    int x = s.top();     // Pop the top element    s.pop();     // Print the current top    // of the stack i.e., x    cout << x << ' ';     // Proceed to print// remaining stack    PrintStack(s);     // Push the element back    s.push(x);} // Driver Codeint main(){    stack<int> s;     // Given stack s    s.push(1);    s.push(2);    s.push(3);    s.push(4);     // Function Call    PrintStack(s);     return 0;}
// Java program for the above approachimport java.util.*; class GFG{     // Function to print stack elements// from top to bottom with the// order of elements unalteredpublic static void PrintStack(Stack<Integer> s){         // If stack is empty    if (s.empty())        return;       // Extract top of the stack    int x = s.peek();       // Pop the top element    s.pop();       // Print the current top    // of the stack i.e., x    System.out.print(x + " ");       // Proceed to print    // remaining stack    PrintStack(s);       // Push the element back    s.push(x);} // Driver codepublic static void main(String[] args){    Stack<Integer> s = new Stack<Integer>();     // Given stack s    s.push(1);    s.push(2);    s.push(3);    s.push(4);       // Function call    PrintStack(s);}} // This code is contributed divyeshrabadiya07
# Python3 program for the# above approachfrom queue import LifoQueue # Function to print stack elements# from top to bottom with the# order of elements unaltereddef PrintStack(s):     # If stack is empty    if (s.empty()):        return;     # Extract top of the    # stack    x = s.get();     # Pop the top element    #s.pop();     # Print current top    # of the stack i.e., x    print(x, end = " ");     # Proceed to print    # remaining stack    PrintStack(s);     # Push the element    # back    s.put(x); # Driver codeif __name__ == '__main__':       s = LifoQueue();     # Given stack s    s.put(1);    s.put(2);    s.put(3);    s.put(4);     # Function call    PrintStack(s); # This code is contributed by Amit Katiyar
// C# program for// the above approachusing System;using System.Collections.Generic;class GFG{     // Function to print stack elements// from top to bottom with the// order of elements unalteredpublic static void PrintStack(Stack<int> s){  // If stack is empty  if (s.Count == 0)    return;   // Extract top of the stack  int x = s.Peek();   // Pop the top element  s.Pop();   // Print the current top  // of the stack i.e., x  Console.Write(x + " ");   // Proceed to print  // remaining stack  PrintStack(s);   // Push the element back  s.Push(x);} // Driver codepublic static void Main(String[] args){  Stack<int> s = new Stack<int>();   // Given stack s  s.Push(1);  s.Push(2);  s.Push(3);  s.Push(4);   // Function call  PrintStack(s);}} // This code is contributed by Rajput-Ji
<script> // Javascript program for the above approach // Function to print stack elements// from top to bottom with the// order of elements unalteredfunction PrintStack(s){    // If stack is empty    if (s.length==0)        return; // Extract top of the stack    var x = s[s.length-1];     // Pop the top element    s.pop();     // Print the current top    // of the stack i.e., x    document.write( x + ' ');     // Proceed to print// remaining stack    PrintStack(s);     // Push the element back    s.push(x);} // Driver Code var s = []; // Given stack ss.push(1);s.push(2);s.push(3);s.push(4); // Function CallPrintStack(s);  </script>
4 3 2 1
Time Complexity: O(N), where N is the number of elements in the given stack.Auxiliary Space: O(N)
Singly LinkedList Stack Approach: This approach discusses the solution to solve the problem for Singly LinkedList Stack representation. Below are the steps:
Push the top element from the given stack into a linked list stack.Print the top element of the singly linked list stack.Pop the top element from the given primary stack.Repeat the above steps in order until the given stack is empty.
Push the top element from the given stack into a linked list stack.
Print the top element of the singly linked list stack.
Pop the top element from the given primary stack.
Repeat the above steps in order until the given stack is empty.
Below is the implementation of the above approach:
C++
Java
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Declare linked list nodestruct Node{    int data;    struct Node* link;}; struct Node* top; // Utility function to add an element// data in the stack insert at the beginningvoid push(int data){         // Create new node temp and allocate memory    struct Node* temp;    temp = new Node();         // Check if stack (heap) is full.    // Then inserting an element would    // lead to stack overflow    if (!temp)    {        cout << "\nHeap Overflow";        exit(1);    }     // Initialize data into temp data field    temp->data = data;     // Put top pointer reference into temp link    temp->link = top;     // Make temp as top of Stack    top = temp;} // Utility function to check if// the stack is empty or notint isEmpty(){    return top == NULL;} // Utility function to return top// element in a stackint peek(){         // Check for empty stack    if (!isEmpty())        return top->data;             // Otherwise stack is empty    else    {        cout << ("Stack is empty");        return -1;    }} // Utility function to pop top// element from the stackvoid pop(){    struct Node* temp;     // Check for stack underflow    if (top == NULL)    {        cout << "\nStack Underflow" << endl;        exit(1);    }    else    {                 // Top assign into temp        temp = top;         // Assign second node to top        top = top->link;         // Destroy connection between        // first and second        temp->link = NULL;    }} // Function to print all the// elements of the stackvoid DisplayStack(){    struct Node* temp;     // Check for stack underflow    if (top == NULL)    {        cout << "\nStack Underflow";        exit(1);    }    else    {        temp = top;        while (temp != NULL)        {                         // Print node data            cout << temp->data << " ";             // Assign temp link to temp            temp = temp->link;        }    }} // Driver Codeint main(){         // Push the elements of stack    push(1);    push(2);    push(3);    push(4);         // Display stack elements    DisplayStack();         return 0;} // This code is contributed by gauravrajput1
// Java program for the above approach import static java.lang.System.exit; // Create Stack Using Linked listclass StackUsingLinkedlist {     // A linked list node    private class Node {        int data;        Node link;    }     // Reference variable    Node top;     // Constructor    StackUsingLinkedlist()    {        this.top = null;    }     // Function to add an element x    // in the stack by inserting    // at the beginning of LL    public void push(int x)    {        // Create new node temp        Node temp = new Node();         // If stack is full        if (temp == null) {            System.out.print("\nHeap Overflow");            return;        }         // Initialize data into temp        temp.data = x;         // Reference into temp link        temp.link = top;         // Update top reference        top = temp;    }     // Function to check if the stack    // is empty or not    public boolean isEmpty()    {        return top == null;    }     // Function to return top element    // in a stack    public int peek()    {        // Check for empty stack        if (!isEmpty()) {             // Return the top data            return top.data;        }         // Otherwise stack is empty        else {            System.out.println("Stack is empty");            return -1;        }    }     // Function to pop top element from    // the stack by removing element    // at the beginning    public void pop()    {        // Check for stack underflow        if (top == null) {            System.out.print("\nStack Underflow");            return;        }         // Update the top pointer to        // point to the next node        top = (top).link;    }     // Function to print the elements and    // restore the stack    public static void    DisplayStack(StackUsingLinkedlist s)    {        // Create another stack        StackUsingLinkedlist s1            = new StackUsingLinkedlist();         // Until stack is empty        while (!s.isEmpty()) {            s1.push(s.peek());             // Print the element            System.out.print(s1.peek()                             + " ");            s.pop();        }    }} // Driver Codepublic class GFG {     // Driver Code    public static void main(String[] args)    {        // Create Object of class        StackUsingLinkedlist obj            = new StackUsingLinkedlist();         // Insert Stack value        obj.push(1);        obj.push(2);        obj.push(3);        obj.push(4);         // Function Call        obj.DisplayStack(obj);    }}
// C# program for the above approachusing System; // Create Stack Using Linked listclass StackUsingLinkedlist{     // A linked list nodepublic class Node{    public int data;    public Node link;} // Reference variableNode top; // Constructorpublic StackUsingLinkedlist(){    this.top = null;} // Function to add an element x// in the stack by inserting// at the beginning of LLpublic void push(int x){         // Create new node temp    Node temp = new Node();     // If stack is full    if (temp == null)    {        Console.Write("\nHeap Overflow");        return;    }     // Initialize data into temp    temp.data = x;     // Reference into temp link    temp.link = top;     // Update top reference    top = temp;} // Function to check if the stack// is empty or notpublic bool isEmpty(){    return top == null;} // Function to return top element// in a stackpublic int peek(){         // Check for empty stack    if (isEmpty() != true)    {                 // Return the top data        return top.data;    }     // Otherwise stack is empty    else    {        Console.WriteLine("Stack is empty");        return -1;    }} // Function to pop top element from// the stack by removing element// at the beginningpublic void pop(){         // Check for stack underflow    if (top == null)    {        Console.Write("\nStack Underflow");        return;    }     // Update the top pointer to    // point to the next node    top = (top).link;} // Function to print the elements and// restore the stackpublic void DisplayStack(StackUsingLinkedlist s){         // Create another stack    StackUsingLinkedlist s1 = new StackUsingLinkedlist();         // Until stack is empty    while (s.isEmpty() != true)    {        s1.push(s.peek());                 // Print the element        Console.Write(s1.peek() + " ");        s.pop();    }}} class GFG{ // Driver Codepublic static void Main(String[] args){         // Create Object of class    StackUsingLinkedlist obj = new StackUsingLinkedlist();     // Insert Stack value    obj.push(1);    obj.push(2);    obj.push(3);    obj.push(4);     // Function Call    obj.DisplayStack(obj);}} // This code is contributed by Amit Katiyar
<script> // JavaScript program for the above approach class Node{    constructor()    {        this.data=0;        this.link=null;    }} // Create Stack Using Linked listclass StackUsingLinkedlist{ constructor(){    this.top=null;} push(x){    // Create new node temp        let temp = new Node();          // If stack is full        if (temp == null) {            document.write("<br>Heap Overflow");            return;        }          // Initialize data into temp        temp.data = x;          // Reference into temp link        temp.link = this.top;          // Update top reference        this.top = temp;} isEmpty(){    return this.top == null;} peek(){    // Check for empty stack        if (!this.isEmpty()) {              // Return the top data            return this.top.data;        }          // Otherwise stack is empty        else {            document.write("Stack is empty");            return -1;        }} pop(){    // Check for stack underflow        if (this.top == null) {            document.write("<br>Stack Underflow");            return;        }          // Update the top pointer to        // point to the next node        this.top = this.top.link;} DisplayStack(s){    // Create another stack     let s1 = new StackUsingLinkedlist();              // Until stack is empty        while (!s.isEmpty()) {            s1.push(s.peek());              // Print the element            document.write(s1.peek()                             + " ");            s.pop();        }}} // Create Object of classlet obj = new StackUsingLinkedlist(); // Insert Stack valueobj.push(1);obj.push(2);obj.push(3);obj.push(4); // Function Callobj.DisplayStack(obj);  // This code is contributed by unknown2108 </script>
4 3 2 1
Time Complexity: O(N), where N is the number of elements in the given stack.Auxiliary Space: O(N)
Array Stack Approach: This approach discusses the solution to problems in Array Stack implementation. Below are the steps:
Push the top element from the given stack into an array stack.Print the top element of the array stack.Pop-out the top element from the given primary stack.Repeat the above steps in order until the given stack is empty.
Push the top element from the given stack into an array stack.
Print the top element of the array stack.
Pop-out the top element from the given primary stack.
Repeat the above steps in order until the given stack is empty.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std;#define MAX 1000 class Stack{ // Stores the index where element// needs to be insertedint top; public:     Stack()    {        top = -1;    }         // Array to store the stack elements    int a[MAX];         // Function that check whether stack    // is empty or not    bool isEmpty()    {        return (top < 0);    }     // Function that pushes the element    // to the top of the stack    bool push(int x)    {                 // If stack is full        if (top >= (MAX - 1))        {            cout << ("Stack Overflow\n");            return false;        }         // Otherwise insert element x        else        {            a[++top] = x;            return true;        }    }     // Function that removes the top    // element from the stack    int pop()    {                 // If stack is empty        if (top < 0)        {            cout << ("Stack Underflow\n");            return 0;        }         // Otherwise remove element        else        {            int x = a[top--];            return x;        }    }     // Function to get the top element    int peek()    {                 // If stack is empty        if (top < 0)        {            cout << ("Stack Underflow\n");            return 0;        }         // Otherwise remove element        else        {            int x = a[top];            return x;        }    }     // Function to print the elements    // and restore the stack    void DisplayStack(Stack s)    {                 // Create another stack        Stack s1;                 // Until stack is empty        while (!s.isEmpty())        {            s1.push(s.peek());                         // Print the element            cout << (s1.peek()) << " ";            s.pop();        }    }}; // Driver Codeint main(){    Stack s;         // Given stack    s.push(1);    s.push(2);    s.push(3);    s.push(4);     // Function Call    s.DisplayStack(s);} // This code is contributed by gauravrajput1
// Java program for the above approach class Stack {     static final int MAX = 1000;     // Stores the index where element    // needs to be inserted    int top;     // Array to store the stack elements    int a[] = new int[MAX];     // Function that check whether stack    // is empty or not    boolean isEmpty()    {        return (top < 0);    }     // Constructor    Stack() { top = -1; }     // Function that pushes the element    // to the top of the stack    boolean push(int x)    {        // If stack is full        if (top >= (MAX - 1)) {            System.out.println(                "Stack Overflow");            return false;        }         // Otherwise insert element x        else {            a[++top] = x;            return true;        }    }     // Function that removes the top    // element from the stack    int pop()    {        // If stack is empty        if (top < 0) {            System.out.println(                "Stack Underflow");            return 0;        }         // Otherwise remove element        else {            int x = a[top--];            return x;        }    }     // Function to get the top element    int peek()    {        // If stack is empty        if (top < 0) {            System.out.println(                "Stack Underflow");            return 0;        }         // Otherwise remove element        else {            int x = a[top];            return x;        }    }     // Function to print the elements    // and restore the stack    static void DisplayStack(Stack s)    {        // Create another stack        Stack s1 = new Stack();         // Until stack is empty        while (!s.isEmpty()) {            s1.push(s.peek());             // Print the element            System.out.print(s1.peek()                             + " ");            s.pop();        }    }} // Driver Codeclass Main {     // Driver Code    public static void main(String args[])    {        Stack s = new Stack();         // Given stack        s.push(1);        s.push(2);        s.push(3);        s.push(4);         // Function Call        s.DisplayStack(s);    }}
# Python3 program for the above approachMAX = 1000  # Stores the index where# element needs to be insertedtop = -1  # Array to store the# stack elementsa = [0]*MAX  # Function that check# whether stack# is empty or notdef isEmpty():  print("4 3 2 1")  return (top > 0)  # Function that pushes# the element to the# top of the stackdef push(x):     global top  # If stack is full  if (top >= (MAX - 1)):    print("Stack Overflow")    return False    # Otherwise insert element x  else:    top+=1    a[top] = x    return True  # Function that removes the top# element from the stackdef pop():  global top  # If stack is empty  if (top < 0):    print("Stack Underflow")    return 0    # Otherwise remove element  else:    top-=1    x = a[top]    return x  # Function to get the top elementdef peek():  # If stack is empty  if (top < 0):    print("Stack Underflow")    return 0    # Otherwise remove element  else:    x = a[top]    return x  # Function to print the elements# and restore the stackdef DisplayStack():    # Until stack is empty  while (not isEmpty()):    push(peek())      # Print the element    #print(peek(), end = " ")    pop()  # Given stackpush(1)push(2)push(3)push(4) # Function CallDisplayStack() # This code is contributed by suresh07.
// C# program for// the above approachusing System;class Stack{   static int MAX = 1000; // Stores the index where// element needs to be insertedint top; // Array to store the// stack elementsint []a = new int[MAX]; // Function that check// whether stack// is empty or notbool isEmpty(){  return (top < 0);} // Constructorpublic Stack(){  top = -1;} // Function that pushes// the element to the// top of the stackpublic bool push(int x){  // If stack is full  if (top >= (MAX - 1))  {    Console.WriteLine("Stack Overflow");    return false;  }   // Otherwise insert element x  else  {    a[++top] = x;    return true;  }} // Function that removes the top// element from the stackpublic int pop(){  // If stack is empty  if (top < 0)  {    Console.WriteLine("Stack Underflow");    return 0;  }   // Otherwise remove element  else  {    int x = a[top--];    return x;  }} // Function to get the top elementpublic int peek(){  // If stack is empty  if (top < 0)  {    Console.WriteLine("Stack Underflow");    return 0;  }   // Otherwise remove element  else  {    int x = a[top];    return x;  }} // Function to print the elements// and restore the stackpublic void DisplayStack(Stack s){  // Create another stack  Stack s1 = new Stack();   // Until stack is empty  while (!s.isEmpty())  {    s1.push(s.peek());     // Print the element    Console.Write(s1.peek() + " ");    s.pop();  }}} class GFG{ // Driver Codepublic static void Main(String []args){  Stack s = new Stack();   // Given stack  s.push(1);  s.push(2);  s.push(3);  s.push(4);   // Function Call  s.DisplayStack(s);}} // This code is contributed by 29AjayKumar
<script>// Javascript program for the above approach let MAX = 1000; class Stack{    // Constructor    constructor()    {        this.top = -1;        this.a = new Array(MAX);    }         // Function that check whether stack    // is empty or not    isEmpty()    {        return (this.top < 0);    }         // Function that pushes the element    // to the top of the stack     push(x)     {         // If stack is full        if (this.top >= (MAX - 1)) {            document.write(                "Stack Overflow<br>");            return false;        }          // Otherwise insert element x        else {            this.a[++this.top] = x;            return true;        }     }           // Function that removes the top    // element from the stack     pop()     {         // If stack is empty        if (this.top < 0) {            document.write(                "Stack Underflow<br>");            return 0;        }          // Otherwise remove element        else {            let x = this.a[this.top--];            return x;        }     }            // Function to get the top element     peek()     {         // If stack is empty        if (this.top < 0) {            document.write(                "Stack Underflow<br>");            return 0;        }          // Otherwise remove element        else {            let x = this.a[this.top];            return x;        }     }      // Function to print the elements    // and restore the stack     DisplayStack(s)     {         // Create another stack        let s1 = new Stack();          // Until stack is empty        while (!s.isEmpty()) {            s1.push(s.peek());              // Print the element            document.write(s1.peek()                             + " ");            s.pop();        }     }} // Driver Codelet s = new Stack(); // Given stacks.push(1);s.push(2);s.push(3);s.push(4); // Function Calls.DisplayStack(s); // This code is contributed by patel2127</script>
4 3 2 1
Time Complexity: O(N), where N is the number of elements in the given stack.Auxiliary Space: O(N)
divyeshrabadiya07
Rajput-Ji
29AjayKumar
amit143katiyar
GauravRajput1
noob2000
unknown2108
patel2127
suresh07
surinderdawra388
Arrays
Linked List
Recursion
School Programming
Stack
Linked List
Arrays
Recursion
Stack
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Multidimensional Arrays in Java
Stack Data Structure (Introduction and Program)
Linear Search
Linked List | Set 1 (Introduction)
Linked List | Set 2 (Inserting a node)
Reverse a linked list
Stack Data Structure (Introduction and Program)
Linked List | Set 3 (Deleting a node)