Dada una Stack S , la tarea es imprimir los elementos de la pila de arriba a abajo de modo que los elementos sigan presentes en la pila sin que se cambie su orden.
Ejemplos:
Entrada: S = {2, 3, 4, 5}
Salida: 5 4 3 2Entrada: S = {3, 3, 2, 2}
Salida: 2 2 3 3
Enfoque recursivo : siga los pasos a continuación para resolver el problema:
- Cree una función recursiva que tenga stack como parámetro.
- Agregue la condición base de que, si la pila está vacía, regrese de la función.
- De lo contrario, almacene el elemento superior en alguna variable X y elimínelo.
- Imprima X , llame a la función recursiva y pase la misma pila en ella.
- Empuje la X almacenada de vuelta a la pila.
A continuación se muestra la implementación del enfoque anterior:
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 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
<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>
Producción
4 3 2 1
Complejidad de tiempo: O(N), donde N es el número de elementos en la pila dada.
Espacio Auxiliar: O(N)
Enfoque de pila de lista enlazada individual : este enfoque analiza la solución para resolver el problema de la representación de pila de lista enlazada individual . A continuación se muestran los pasos:
- Empuje el elemento superior de la pila dada a una pila de lista enlazada .
- Imprime el elemento superior de la pila de listas enlazadas individualmente .
- Extraiga el elemento superior de la pila principal dada.
- Repita los pasos anteriores en orden hasta que la pila dada esté vacía.
A continuación se muestra la implementación del enfoque anterior:
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
Javascript
<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>
Producción
4 3 2 1
Complejidad de tiempo: O(N), donde N es el número de elementos en la pila dada.
Espacio Auxiliar: O(N)
Enfoque de Array Stack : este enfoque analiza la solución a los problemas en la implementación de Array Stack . A continuación se muestran los pasos:
- Empuje el elemento superior de la pila dada a una pila de array .
- Imprime el elemento superior de la pila de arreglos .
- Extraiga el elemento superior de la pila principal dada.
- Repita los pasos anteriores en orden hasta que la pila dada esté vacía.
A continuación se muestra la implementación del enfoque anterior:
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);
}
}
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
<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>
Producción
4 3 2 1
Complejidad de tiempo: O(N), donde N es el número de elementos en la pila dada.
Espacio Auxiliar: O(N)
Publicación traducida automáticamente
Artículo escrito por kmsehab130 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA