从上到下打印堆栈元素

给定一个 Stack S ，任务是从上到下打印堆栈中的元素，这样元素仍然存在于堆栈中而不会改变它们的顺序。

例子：

Input: S = {2, 3, 4, 5}
Output: 5 4 3 2

Input: S = {3, 3, 2, 2}
Output: 2 2 3 3

递归方法：按照以下步骤解决问题：

1. 创建一个以堆栈为参数的递归函数。
2. 添加基本条件，如果堆栈为空，则从函数返回。
3. 否则，将顶部元素存储在某个变量X 中并将其删除。
4. 打印X ，调用递归函数并在其中传递相同的堆栈。
5. 将存储的X推回堆栈。

下面是上述方法的实现：

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 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 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 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 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 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 by Rajput-Ji

输出

4 3 2 1

时间复杂度： O(N)，其中 N 是给定堆栈中的元素数。
辅助空间： O(N)

Singly LinkedList Stack Approach：该方法讨论了解决Singly LinkedList Stack 表示问题的解决方案。以下是步骤：

1. 将给定堆栈中的顶部元素推入链表堆栈。
2. 打印单向链表堆栈的顶部元素。
3. 从给定的主堆栈中弹出顶部元素。
4. 按顺序重复上述步骤，直到给定的堆栈为空。

下面是上述方法的实现：

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

输出

4 3 2 1

时间复杂度： O(N)，其中 N 是给定堆栈中的元素数。
辅助空间： O(N)

Array Stack Approach：这种方法讨论了解决Array Stack实现中问题的方法。以下是步骤：

1. 将给定堆栈中的顶部元素推入数组堆栈。
2. 打印数组堆栈的顶部元素。
3. 从给定的主堆栈中弹出顶部元素。
4. 按顺序重复上述步骤，直到给定的堆栈为空。

下面是上述方法的实现：

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

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

时间复杂度： O(N)，其中 N 是给定堆栈中的元素数。
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live