Imprimir elementos de pila de abajo hacia arriba

Dada una pila s, la tarea es imprimir los elementos de la pila de abajo hacia arriba, de modo que los elementos todavía estén presentes en la pila sin que se cambie su orden en la pila.

Ejemplos: 

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

Output :1 2 3 4

Enfoque 1 (Recursividad): La idea es sacar el elemento de la pila y llamar a la función recursiva PrintStack. Una vez que la pila se vacía, comience a imprimir el último elemento que se extrajo y el último elemento que se extrajo fue el elemento más inferior. Por lo tanto, los elementos se imprimirán de abajo hacia arriba. Ahora empuje hacia atrás el elemento que se imprimió, esto preservará el orden de los elementos en la pila.

A continuación se muestra la implementación del enfoque anterior:

// 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;
}

// 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.

# 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

// 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 */

<script>
 
// Javascript program to print the elements
// of a stack from bottom to top
 
// Recursive function to print stack
// elements from bottom to top without
// changing their order
function PrintStack(s)
{
     
    // If stack is empty then return
    if (s.length == 0)
        return;
     
    var x = s[s.length - 1];
 
    // Pop the top element of the stack
    s.pop();
 
    // Recursively call the function PrintStack
    PrintStack(s);
 
    // Print the stack element starting
    // from the bottom
    document.write(x + " ");
 
    // Push the same element onto the stack
    // to preserve the order
    s.push(x);
}
 
// Driver code
 
// Stack s
var s = [];
s.push(1);
s.push(2);
s.push(3);
s.push(4);
 
PrintStack(s);
 
// This code is contributed by importantly
 
</script>

1 2 3 4

Complejidad temporal : O(N) 
Espacio auxiliar: O(N) 

Enfoque 2 (usando otra pila): la idea es empujar cada elemento a otra pila temporal y luego imprimir elementos de la pila temporal. 

// 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;
}

// 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

# 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

// 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

<script>
 
// JavaScript program to print the elements of a
// stack from bottom to top
 
// Recursive function to print stack elements
// from bottom to top without changing
// their order
function PrintStack(s)
{
    var temp = [];
    while (s.length!=0)
    {
        temp.push(s[s.length-1]);
        s.pop();
    }  
 
    while (temp.length!=0)
    {
        var t = temp[temp.length-1];
        document.write( t + " ");
        temp.pop();
 
        // To restore contents of
        // the original stack.
        s.push(t); 
    }
}
 
// Driver code
// Stack s
var s = [];
s.push(1);
s.push(2);
s.push(3);
s.push(4);
PrintStack(s);
 
 
</script>

1 2 3 4

Complejidad temporal : O(N) 
Espacio auxiliar: O(N)