数据结构之栈(Stack)的实现详解

目录

1、什么是栈（Stack）？

2、栈的基本操作

3、栈的应用场景有哪些？

4、栈的两种实现方式：数组和链表

5、LeetCode算法题示例

---

1、什么是栈（Stack）？

        堆栈是一种线性数据结构，其插入新元素和删除现有元素都发生在堆栈的顶部。

        栈（Stack）按照"后进先出"（Last-In-First-Out，LIFO）的原则存储和访问数据。栈类似于现实生活中的堆叠物体，比如一摞书或者一堆盘子。

2、栈的基本操作

        栈的基本操作包括以下三个：

1. 入栈（Push）：将元素插入到栈的顶部。新元素成为栈顶。
2. 出栈（Pop）：移除栈顶的元素并返回它。栈顶的下一个元素成为新的栈顶。
3. 查看栈顶元素（Peek）：返回栈顶的元素，但不对栈进行修改。

        除了这些基本操作，栈还具有其他辅助操作，例如判断栈是否为空、获取栈的大小等。这些辅助操作可以根据具体的实现方式而有所不同。

        需要注意的是，在使用栈进行操作时，我们应该始终关注栈的状态，避免栈溢出（Stack Overflow）或者在空栈上执行出栈操作（Empty Stack）的错误。

        时间复杂度分析：

Operations	Complexity
Push	O(1)
Pop	O(1)
Peek	O(1)

3、栈的应用场景有哪些？

        栈在计算机科学和软件开发中有许多应用场景。以下是一些常见的栈的应用场景：

1. 函数调用：在编程语言中，栈被用于跟踪函数的执行上下文。每当一个函数被调用时，相关的执行上下文被压入栈中，包括函数的参数、局部变量以及返回地址。当函数执行完成后，对应的上下文从栈中弹出，程序回到调用函数的位置继续执行。
2. 表达式求值：栈在解析和求解表达式时非常有用。特别是在后缀表达式（逆波兰表达式）的求值中，栈可以用于存储操作数和运算符，并按照运算符的优先级进行计算。
3. 括号匹配：栈在处理括号匹配问题时非常有用。我们可以使用栈来验证括号的正确匹配，例如检查括号是否完全闭合、括号的顺序是否正确等。
4. 浏览器历史记录：浏览器使用栈来实现访问历史记录。每当用户访问一个新页面时，该页面的 URL 被推入栈中。当用户点击后退按钮时，最近访问的页面 URL 从栈中弹出，浏览器加载上一个页面。
5. 撤销操作：在文本编辑器和图形处理软件中，栈可以用于实现撤销操作。每当执行一个操作时，相关的状态信息被推入栈中。当用户要撤销操作时，可以从栈中弹出最近的状态，恢复到之前的状态。
6. 历史记录管理：栈可以用于管理历史记录，例如命令历史记录、用户界面导航历史记录等。用户执行的每个操作都可以被推入栈中，以便回溯和导航。

        这些只是栈在实际应用中的一些例子，栈在许多其他领域也有广泛的应用，例如编译器、操作系统、深度优先搜索等。栈的特性使其在许多问题的解决中非常有用，特别是需要“后进先出”（LIFO）操作的场景。

4、栈的两种实现方式：数组和链表

        （1）使用数组实现堆栈:

class Stack {

    static final int MAX = 1000;
    int top;
    int a[] = new int[MAX]; // Maximum size of Stack

    boolean isEmpty() {
        return (top < 0);
    }

    Stack() {
        top = -1;
    }
    // 入栈
    boolean push(int x) {
        if (top >= (MAX - 1)) {
            System.out.println("Stack Overflow");
            return false;
        } else {
            a[++top] = x;
            System.out.println(x + " pushed into stack");
            return true;
        }
    }
    //出栈
    int pop() {
        if (top < 0) {
            System.out.println("Stack Underflow");
            return 0;
        } else {
            int x = a[top--];
            return x;
        }
    }
    //查看栈顶元素
    int peek() {
        if (top < 0) {
            System.out.println("Stack Underflow");
            return 0;
        } else {
            int x = a[top];
            return x;
        }
    }

    void print() {
        for (int i = top; i > -1; i--) {
            System.out.print(" " + a[i]);
        }
    }
}

// Driver code
class Main {

    public static void main(String args[]) {
        Stack s = new Stack();
        s.push(10);
        s.push(20);
        s.push(30);
        System.out.println(s.pop() + " Popped from stack");
        System.out.println("Top element is :" + s.peek());
        System.out.print("Elements present in stack :");
        s.print();
    }
}

        （2）使用链表实现堆栈：

public class StackAsLinkedList {

    StackNode root;

    static class StackNode {

        int       data;
        StackNode next;

        StackNode(int data) {
            this.data = data;
        }
    }

    public boolean isEmpty() {
        if (root == null) {
            return true;
        } else {
            return false;
        }
    }

    public void push(int data) {
        StackNode newNode = new StackNode(data);

        if (root == null) {
            root = newNode;
        } else {
            StackNode temp = root;
            root         = newNode;
            newNode.next = temp;
        }
        System.out.println(data + " pushed to stack");
    }

    public int pop() {
        int popped = Integer.MIN_VALUE;
        if (root == null) {
            System.out.println("Stack is Empty");
        } else {
            popped = root.data;
            root   = root.next;
        }
        return popped;
    }

    public int peek() {
        if (root == null) {
            System.out.println("Stack is empty");
            return Integer.MIN_VALUE;
        } else {
            return root.data;
        }
    }

    // Driver code
    public static void main(String[] args) {
        StackAsLinkedList sll = new StackAsLinkedList();
        sll.push(10);
        sll.push(20);
        sll.push(30);
        System.out.println(sll.pop() + " popped from stack");
        System.out.println("Top element is " + sll.peek());
    }
}

        数组实现的栈和链表实现的栈的区别：//基本上也就是数组和链表的区别

• 数组实现的栈：使用数组作为底层数据结构，通过索引来访问栈中的元素。数组实现的栈具有固定的大小，需要预先指定最大容量。
• 链表实现的栈：使用链表作为底层数据结构，通过节点之间的指针关系来访问栈中的元素。链表实现的栈可以动态调整大小，不受固定容量的限制。

        栈的优点和缺点总结：

        优点：

1. 简单高效：栈的基本操作（入栈和出栈）都可以在常数时间内完成，因为元素是从堆栈顶部添加和删除的，所以栈操作非常高效。
2. 高效的内存利用：Stack使用一个连续的内存块，这使得它比其他数据结构更有效地利用内存。
3. 适合处理临时数据：栈适用于存储和处理临时数据，特别是在函数调用和递归算法中。栈的局部性使得它对于处理临时性数据非常有效。
4. 支持撤销和回溯：栈的特性使其非常适合实现撤销和回溯操作。每个操作的状态可以被压入栈中，当需要撤销时，可以通过弹出栈顶状态恢复到之前的状态。

        缺点：//优点也是缺点，缺点也是优点，在不同情况下进行分析

1. 有限容量：堆栈数据结构的容量有限，因为它只能容纳固定数量的元素。如果堆栈已满，添加新元素可能会导致堆栈溢出，从而导致数据丢失。// 如数组实现的栈
2. 不支持随机访问：栈不支持随机访问，即不能在任意位置插入或删除元素。只能在栈顶进行插入和删除操作。

        栈在某些场景下具有明显的优势和便利性，但在其他场景下可能会有一些限制和不足之处。

5、LeetCode算法题示例

        【原题】：

        【解答】：下边是代码的具体实现

import java.util.Stack;

public class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '(' || c == '{' || c == '[') {
                stack.push(c);
            } else {
                // 如果栈为空-根据题来设置
                if (stack.isEmpty()) {
                    return false;
                }
                Character pop = stack.pop();
                if (c == ')' && pop != '(') {
                    return false;
                }
                if (c == ']' && pop != '[') {
                    return false;
                }
                if (c == '}' && pop != '{') {
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }

    public static void main(String[] args) {
        System.out.println((new Solution()).isValid("()[]{}"));
        System.out.println((new Solution()).isValid("()]{}"));
    }
}

        至此，本文结束。