Print Stack Elements from Bottom to Top

Given a stack s, the task is to print the elements of the stack from bottom to top, such that the elements are still present in the stack without their order being changed in the stack.

Examples: 

Input : 
       
       
|   4    |
|   3    |
|   2    |
|   1    |
|________|

Output :1 2 3 4

Approach 1 (Recursion): The idea is to pop the element of the stack and call the recursive function PrintStack. Once the stack becomes empty start printing the element which was popped last and the last element that was popped was the bottom-most element. Thus, elements will be printed from bottom to top. Now push back the element that was printed, this will preserve the order of the elements in the stack.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to print the elements of a
// stack from bottom to top
#include <bits/stdc++.h>
using namespace std;
 
// Recursive function to print stack elements
// from bottom to top without changing
// their order
void PrintStack(stack<int> s)
{
    // If stack is empty then return
    if (s.empty())
        return;
     
 
    int x = s.top();
 
    // Pop the top element of the stack
    s.pop();
 
    // Recursively call the function PrintStack
    PrintStack(s);
 
    // Print the stack element starting
    // from the bottom
    cout << x << " ";
 
    // Push the same element onto the stack
    // to preserve the order
    s.push(x);
}
 
// Driver code
int main()
{
    // Stack s
    stack<int> s;
 
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);
 
    PrintStack(s);
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to print the elements of a
// stack from bottom to top
import java.util.*;
 
class GfG
{
 
// Recursive function to print stack elements
// from bottom to top without changing
// their order
static void PrintStack(Stack<Integer> s)
{
    // If stack is empty then return
    if (s.isEmpty())
        return;
     
    int x = s.peek();
 
    // Pop the top element of the stack
    s.pop();
 
    // Recursively call the function PrintStack
    PrintStack(s);
 
    // Print the stack element starting
    // from the bottom
    System.out.print(x + " ");
 
    // Push the same element onto the stack
    // to preserve the order
    s.push(x);
}
 
// Driver code
public static void main(String[] args)
{
    // Stack s
    Stack<Integer> s = new Stack<Integer> ();
 
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);
 
    PrintStack(s);
}
}
 
// This code is contributed by Prerna Saini.

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to print the elements of a
# stack from bottom to top
 
# Stack class with all functionality of a stack
import sys
class Stack:
    def __init__(self):
        self.s = []
 
    def push(self, data):
        self.s.append(data)
     
    def pop(self):
        return self.s.pop()
 
    def peek(self):
        return self.s[-1]
    def count(self):
        return len(self.s)
 
# Recursive function to print stack elements
# from bottom to top without changing
# their order
def printStack(s):
     
    # if stack is empty then simply return
    if s.count() == 0:
        return
    x = s.peek()
 
    # pop top most element of the stack
    s.pop()
     
    # recursively call the function printStack
    printStack(s)
     
    # Print the stack element starting
    # from the bottom
    print("{} ".format(x), end = "")
     
    # Push the same element onto the stack
    # to preserve the order
    s.push(x)
 
# Driver code
if __name__=='__main__':
    s=Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    s.push(4)
 
    printStack(s)
 
# This code is contributed by Vikas Kumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to print the elements of a
// stack from bottom to top
using System;
using System.Collections.Generic;
 
class GfG
{
 
// Recursive function to print stack elements
// from bottom to top without changing
// their order
static void PrintStack(Stack<int> s)
{
    // If stack is empty then return
    if (s.Count == 0)
        return;
     
    int x = s.Peek();
 
    // Pop the top element of the stack
    s.Pop();
 
    // Recursively call the function PrintStack
    PrintStack(s);
 
    // Print the stack element starting
    // from the bottom
    Console.Write(x + " ");
 
    // Push the same element onto the stack
    // to preserve the order
    s.Push(x);
}
 
// Driver code
public static void Main()
{
    // Stack s
    Stack<int> s = new Stack<int> ();
 
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
 
    PrintStack(s);
}
}
 
/* This code contributed by PrinciRaj1992 */

chevron_right


Output: 



1 2 3 4


 

Approach 2 (Using another stack): The idea is to push every element into another temporary stack and then print elements of the temporary stack. 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to print the elements of a
// stack from bottom to top
#include <bits/stdc++.h>
using namespace std;
 
// Recursive function to print stack elements
// from bottom to top without changing
// their order
void PrintStack(stack<int> s)
{
    stack<int> temp;
    while (s.empty() == false)
    {
        temp.push(s.top());
        s.pop();
    }  
 
    while (temp.empty() == false)
    {
        int t = temp.top();
        cout << t << " ";
        temp.pop();
 
        // To restore contents of
        // the original stack.
        s.push(t); 
    }
}
 
// Driver code
int main()
{
    // Stack s
    stack<int> s;
 
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);
 
    PrintStack(s);
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to print the
// elements of a stack from
// bottom to top
import java.util.*;
class Main{
   
// Recursive function to print
// stack elements from bottom
// to top without changing
// their order
public static void PrintStack(Stack<Integer> s)
{
  Stack<Integer> temp = new Stack<Integer>();
   
  while (s.empty() == false)
  {
    temp.push(s.peek());
    s.pop();
  }  
 
  while (temp.empty() == false)
  {
    int t = temp.peek();
    System.out.print(t + " ");
    temp.pop();
 
    // To restore contents of
    // the original stack.
    s.push(t); 
  }
}
 
// Driver code
public static void main(String[] args)
{
  // Stack s
  Stack<Integer> s = new Stack<Integer>();
 
  s.push(1);
  s.push(2);
  s.push(3);
  s.push(4);
  PrintStack(s);
}
}
 
// This code is contributed by divyeshrabadiya07

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to print the elements of a
# stack from bottom to top
 
# Stack class with all functionality of a stack
import sys
class Stack:
    def __init__(self):
        self.s = []
 
    def push(self, data):
        self.s.append(data)
     
    def pop(self):
        return self.s.pop()
 
    def peek(self):
        return self.s[-1]
    def count(self):
        return len(self.s)
 
# Recursive function to print stack elements
# from bottom to top without changing
# their order
def printStack(s):
    temp = Stack()
    while(s.count() > 0):
        temp.push(s.peek())
        s.pop()
     
    while(temp.count() > 0):
        t = temp.peek()
        print("{} " . format(temp.peek()), end = "")
        temp.pop()
 
        # Restore the contents of original stack
        s.push(t)
 
# Driver code
if __name__=='__main__':
    s = Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    s.push(4)
 
    printStack(s)
 
# This code is contributed by Vikash Kumar 37

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to print the elements of
// a stack from bottom to top
using System;
using System.Collections;
 
class GFG{
 
// Recursive function to print stack
// elements from bottom to top without
// changing their order
static void PrintStack(Stack s)
{
    Stack temp = new Stack();
    while (s.Count != 0)
    {
        temp.Push(s.Peek());
        s.Pop();
    }  
  
    while (temp.Count != 0)
    {
        int t = (int)temp.Peek();
        Console.Write(t + " ");
        temp.Pop();
  
        // To restore contents of
        // the original stack.
        s.Push(t); 
    }
}
 
// Driver Code
public static void Main(string[] args)
{
     
    // Stack s
    Stack s = new Stack();
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
 
    PrintStack(s);
}
}
 
// This code is contributed by rutvik_56

chevron_right


Output: 

1 2 3 4


 

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 arrow_drop_up

Check out this Author's contributed articles.

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

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.