Print Stack Elements from Top to Bottom

Difficulty Level : Hard
Last Updated : 07 Dec, 2020

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.

Below is the implementation of the above approach:

C++

// 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 unaltered
void 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 Code
int 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

// Java program for the above approach 
import java.util.*;
 
class GFG{
     
// Function to print stack elements 
// from top to bottom with the 
// order of elements unaltered 
public 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 code
public 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

# Python3 program for the 
# above approach
from queue import LifoQueue
 
# Function to prstack elements
# from top to bottom with the
# order of elements unaltered
def 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 code
if __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#

// C# program for 
// the above approach 
using System;
using System.Collections.Generic;
class GFG{
     
// Function to print stack elements 
// from top to bottom with the 
// order of elements unaltered 
public 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 code
public 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

Output

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.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h> 
using namespace std; 
 
// Declare linked list node 
struct Node 
{
    int data; 
    struct Node* link; 
}; 
 
struct Node* top; 
 
// Utility function to add an element 
// data in the stack insert at the beginning 
void 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 not 
int isEmpty() 
{ 
    return top == NULL; 
} 
 
// Utility function to return top 
// element in a stack 
int 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 stack 
void 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 stack 
void 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 Code 
int 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

// Java program for the above approach
 
import static java.lang.System.exit;
 
// Create Stack Using Linked list
class 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 Code
public 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#

// C# program for the above approach
using System;
 
// Create Stack Using Linked list
class StackUsingLinkedlist{
     
// A linked list node
public class Node 
{
    public int data;
    public Node link;
}
 
// Reference variable
Node top;
 
// Constructor
public 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)
    {
        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 not
public bool isEmpty()
{
    return top == null;
}
 
// Function to return top element
// in a stack
public 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 beginning
public 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 stack
public 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 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);
}
}
 
// This code is contributed by Amit Katiyar

Output

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.

Below is the implementation of the above approach:

C++

// 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 inserted
int 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 Code
int 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

// 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 Code
class 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);
    }
}

C#

// C# program for 
// the above approach
using System;
class Stack{
   
static 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
bool isEmpty()
{
  return (top < 0);
}
 
// Constructor
public Stack() 
{ 
  top = -1; 
}
 
// Function that pushes 
// the element to the 
// top of the stack
public 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 stack
public 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 element
public 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 stack
public 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 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);
}
}
 
// This code is contributed by 29AjayKumar

Output

4 3 2 1

Time Complexity: O(N), where N is the number of elements in the given stack.
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

Related Articles

C++

Java

Python3

C#

C++

Java

C#

C++

Java

C#