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 2Input: 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 |
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 |
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 |
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.