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++ 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 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 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# 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 |
<script> // Javascript program for the above approach // Function to print stack elements // from top to bottom with the // order of elements unaltered function 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 s s.push(1); s.push(2); s.push(3); s.push(4); // Function Call PrintStack(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.
Below is the implementation of the above approach:
// 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 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# 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 |
<script> // JavaScript program for the above approach class Node { constructor()
{
this .data=0;
this .link= null ;
}
} // Create Stack Using Linked list class 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 class let 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 unknown2108 </script> |
class StackUsingLinkedlist:
# A linked list node
class Node:
def __init__( self , data):
self .data = data
self .link = None
def __init__( self ):
# Reference variable
self .top = None
# Function to add an element x
# in the stack by inserting
# at the beginning of LL
def push( self , x):
# Create new node temp
temp = self .Node(x)
# If stack is full
if temp is None :
print ( "\nHeap Overflow" )
return
# Reference into temp link
temp.link = self .top
# Update top reference
self .top = temp
# Function to check if the stack
# is empty or not
def is_empty( self ):
return self .top is None
# Function to return top element
# in a stack
def peek( self ):
# Check for empty stack
if not self .is_empty():
# Return the top data
return self .top.data
# Otherwise stack is empty
else :
print ( "Stack is empty" )
return - 1
# Function to pop top element from
# the stack by removing element
# at the beginning
def pop( self ):
# Check for stack underflow
if self .top is None :
print ( "\nStack Underflow" )
return
# Update the top pointer to
# point to the next node
self .top = self .top.link
# Function to print the elements and
# restore the stack
@staticmethod
def display_stack(s):
# Create another stack
s1 = StackUsingLinkedlist()
# Until stack is empty
while not s.is_empty():
s1.push(s.peek())
# Print the element
print (s1.peek(), end = " " )
s.pop()
# Driver Code
if __name__ = = '__main__' :
# Create Object of class
obj = StackUsingLinkedlist()
# Insert Stack value
obj.push( 1 )
obj.push( 2 )
obj.push( 3 )
obj.push( 4 )
# Function Call
StackUsingLinkedlist.display_stack(obj)
|
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++ 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 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 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# 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 |
<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 Code let 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 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)