从零开始：Java中的栈

2023-09-11 23:02:06

栈：计算机科学中的关键数据结构

在计算机科学领域，栈是一种至关重要的数据结构，它遵循后进先出 (LIFO) 原则。这意味着栈中最后加入的元素将首先被移除。栈在许多计算机操作中扮演着至关重要的角色，包括：

函数调用管理
表达式求值
内存管理
图形学
操作系统

使用数组或链表实现栈

栈可以通过使用数组或链表来实现。本文将重点介绍如何使用数组来模拟栈。

数组实现的栈示例

public class Stack {

    private int[] arr;
    private int top;

    public Stack(int size) {
        arr = new int[size];
        top = -1;
    }

    public void push(int value) {
        if (top == arr.length - 1) {
            System.out.println("Stack Overflow!");
            return;
        }
        arr[++top] = value;
    }

    public int pop() {
        if (top == -1) {
            System.out.println("Stack Underflow!");
            return -1;
        }
        return arr[top--];
    }

    public int peek() {
        if (top == -1) {
            System.out.println("Stack Underflow!");
            return -1;
        }
        return arr[top];
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public void printStack() {
        for (int i = top; i >= 0; i--) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

Java 中的 Stack 类

Java 提供了一个内置的 Stack 类，它继承自 Vector 类。Stack 类提供了许多有用的方法，包括：

push(Object object)：将指定对象推入栈中。
pop()：从栈中弹出并返回栈顶对象。
peek()：返回栈顶对象，但不将其弹出。
search(Object object)：返回指定对象在栈中的位置（从栈顶开始计数）。
isEmpty()：如果栈为空，则返回 true；否则返回 false。

括号匹配示例

栈在计算机科学中的一个常见应用是括号匹配。我们可以使用栈来检查一串括号是否正确匹配。

public class BracketMatcher {

    private Stack<Character> stack;

    public BracketMatcher() {
        stack = new Stack<>();
    }

    public boolean isBalanced(String expression) {
        for (char ch : expression.toCharArray()) {
            if (isOpeningBracket(ch)) {
                stack.push(ch);
            } else if (isClosingBracket(ch)) {
                if (stack.isEmpty()) {
                    return false;
                }
                char top = stack.pop();
                if (!bracketsMatch(top, ch)) {
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }

    private boolean isOpeningBracket(char ch) {
        return ch == '(' || ch == '{' || ch == '[';
    }

    private boolean isClosingBracket(char ch) {
        return ch == ')' || ch == '}' || ch == ']';
    }

    private boolean bracketsMatch(char opening, char closing) {
        return (opening == '(' && closing == ')') ||
                (opening == '{' && closing == '}') ||
                (opening == '[' && closing == ']');
    }
}