数据结构-栈和队列-优快云博客

本文介绍了如何使用数组实现栈和队列，并展示了如何利用栈解决有效括号问题。首先，详细展示了栈和队列的基本操作，包括数组实现的栈和循环队列。循环队列在删除元素时避免了数组元素移动的高复杂度。然后，通过一个解决方案，利用栈来检查输入字符串中的括号是否有效，遵循括号匹配规则。该方法通过遍历字符串，遇到左括号压栈，遇到右括号则与栈顶元素比较，确保正确匹配。最后，文章通过示例验证了该方法的有效性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

之前我们实现了数组，现在用数组来实现栈和队列：

栈：先进后出

public interface Stack<E> {
    //获取元素个数
    int getSize();
    //判断元素个数是否为空
    boolean isEmpty();
    //栈中添加元素
    void push(E e);
    //取出并删除栈顶元素
    E pop();
    //取出栈顶元素
    E peek();
}

import Array.Array;

public class ArrayStack<E> implements Stack<E> {

    private Array<E> array;

    public ArrayStack(int capacity) {
        array = new Array<E>(capacity);
    }

    public ArrayStack() {
        array = new Array<E>();
    }

    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    public int getCapacity() {
        return array.getCapacity();
    }

    @Override
    public void push(E e) {
        array.addLast(e);
    }

    @Override
    public E pop() {
        return array.removeLast();
    }

    @Override
    public E peek() {
        return array.getLast();
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Stack: ");
        res.append('[');
        for (int i = 0; i < array.getSize(); i++) {
            res.append(array.get(i));
            if (i != array.getSize() - 1) {
                res.append(", ");
            }
        }
        res.append("] top");
        return res.toString();
    }
}

队列：　先进先出

public interface Queue<E> {
    int getSize();
    boolean isEmpty();
    //添加元素
    void enqueue(E e);
    //获取并删除队首元素
    E dequeue();
    //获取队首元素
    E getFront();
}

import Array.Array;

public class ArrayQueue<E> implements Queue<E> {

    private Array<E> array;

    public ArrayQueue() {
        array = new Array<E>();
    }


    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    @Override
    public void enqueue(E e) {
        array.addLast(e);
    }

    @Override
    public E dequeue() {
        return array.removeFirst();
    }

    @Override
    public E getFront() {
        return array.getFirst();
    }

    @Override
    public String toString() {

        StringBuilder res = new StringBuilder();
        res.append("Queue: ");
        res.append("front [");
        for (int i = 0; i < array.getSize(); i++) {
            res.append(array.get(i));
            if (i != array.getSize() - 1) {
                res.append(", ");
            }
        }
        res.append("] tail");
        return res.toString();
    }
}

如上，使用数组作为栈和队列的底层结构，实现各自的特性，无非就是往数组添加和取出元素的顺序。

但是，使用数组实现的队列，删除时候，ａｒｒａｙ中所有元素都要往前移动，复杂度是O（ｎ），下面将数组在队列中的实现优化一下，变成循环队列。

public class LoopQueue<E> implements Queue<E> {

    private E[] data;
    //第一个元素位置
    private int front;
    //下一个添加元素的位置
    private int tail;

    public LoopQueue(int capacity) {
        //因为tail是下一个元素的位置，所以当队列满了之后，需要多一个空间存放tail的位置
        //capacity是真正的可存放元素的个数，达到capacity就认为队列满了
        data = (E[]) new Object[capacity + 1];
        front = 0;
        tail = 0;
    }

    public LoopQueue() {
        this(10);
    }

    public int getCapacity() {
        return data.length - 1;
    }

    @Override
    public int getSize() {
        if (tail >= front) {
            return tail - front;
        }
        return tail - front + data.length;
    }

    @Override
    public void enqueue(E e) {
        if ((tail + 1) % data.length == front) {
            resize(getCapacity() * 2);
        }
        data[tail] = e;
        tail = (tail + 1) % data.length;
    }

    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity + 1];
        int sz = getSize();
        for (int i = 0; i < sz; i++) {
            newData[i] = data[(i + front) % data.length];
        }
        data = newData;
        front = 0;
        tail = sz;
    }

    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new IllegalArgumentException("QueueAndStack is empty.");
        }
        E ret = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        if (getSize() == getCapacity() / 4 && getCapacity() / 2 != 0) {
            resize(getCapacity() / 2);
        }
        return ret;
    }

    @Override
    public E getFront() {
        if (isEmpty()) {
            throw new IllegalArgumentException("QueueAndStack is empty.");
        }
        return data[front];
    }


    @Override
    public boolean isEmpty() {
        return getSize() == 0;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("QueueAndStack: size = %d , capacity = %d\n", getSize(), getCapacity()));
        res.append("front [");
        for (int i = front; i != tail; i = (i + 1) % data.length) {
            res.append(data[i]);
            if ((i + 1) % data.length != tail) {
                res.append(", ");
            }
        }
        res.append("] tail");
        return res.toString();
    }
}

如上，循环队列中不像数组的实现那样，添加或删除都不需要移动元素，只需要移动首尾指针，复杂度为O（１）。

现在使用栈来做一道题：

/**
 * 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
 * <p>
 * 有效字符串需满足：
 * <p>
 * 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 示例 1：
 * <p>
 * 输入：s = "()" 输出：true 示例 2：
 * <p>
 * 输入：s = "()[]{}" 输出：true 示例 3：
 * <p>
 * 输入：s = "(]" 输出：false 示例 4：
 * <p>
 * 输入：s = "([)]" 输出：false 示例 5：
 * <p>
 * 输入：s = "{[]}" 输出：tru
 * <p>
 * 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/valid-parentheses
 */
class Solution {

    public boolean isValid(String s) {

        Stack<Character> stack = new ArrayStack<>();
        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;
                }

                char topChar = stack.pop();
                if (c == ')' && topChar != '(') {
                    return false;
                }
                if (c == ']' && topChar != '[') {
                    return false;
                }
                if (c == '}' && topChar != '{') {
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }

    public static void main(String[] args) {

        System.out.println((new Solution()).isValid("()[]{}"));
        System.out.println((new Solution()).isValid("([)]"));
    }
}

本来呢，到这里就算结束了，代码就是核心。这优快云发布非说字数不够，，那就添加吧！

字数不够废话来凑！字数不够废话来凑！字数不够废话来凑！