# Print Stack Elements from Top to Bottom

• Difficulty Level : Hard
• Last Updated : 26 Jul, 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:

1. Create a recursive function having stack as the parameter.
2. Add the base condition that, if the stack is empty, return from the function.
3. Otherwise, store the top element in some variable X and remove it.
4. Print X, call the recursive function and pass the same stack in it.
5. Push the stored X back to the Stack.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``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 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 s = ``new` `Stack(); `` ` `    ``// 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 print stack 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`

## Javascript

 ``

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:

1. Push the top element from the given stack into a linked list stack.
2. Print the top element of the singly linked list stack.
3. Pop the top element from the given primary stack.
4. 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  ``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`

## Javascript

 ``

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:

1. Push the top element from the given stack into an array stack.
2. Print the top element of the array stack.
3. Pop-out the top element from the given primary stack.
4. 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 ``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);``    ``}``}`

## Python3

 `# Python3 program for the above approach``MAX` `=` `1000``  ` `# Stores the index where``# element needs to be inserted``top ``=` `-``1``  ` `# Array to store the``# stack elements``a ``=` `[``0``]``*``MAX``  ` `# Function that check``# whether stack``# is empty or not``def` `isEmpty():``  ``print``(``"4 3 2 1"``)``  ``return` `(top > ``0``)``  ` `# Function that pushes``# the element to the``# top of the stack``def` `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 stack``def` `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 element``def` `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 stack``def` `DisplayStack():``  ` `  ``# Until stack is empty``  ``while` `(``not` `isEmpty()):``    ``push(peek())``  ` `    ``# Print the element``    ``#print(peek(), end = " ")``    ``pop()``  ` `# Given stack``push(``1``)``push(``2``)``push(``3``)``push(``4``)`` ` `# Function Call``DisplayStack()`` ` `# This code is contributed by suresh07.`

## 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`

## Javascript

 ``

Output

`4 3 2 1`

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

My Personal Notes arrow_drop_up