深入剖析栈练习题，揭开数据结构与算法之美

2023-11-09 20:37:12

在数据结构与算法领域，栈和队列是两大基本数据结构，它们以其独特的特性在各种应用程序中发挥着至关重要的作用。在之前的文章中，我们深入探讨了栈的理论基础和代码实现，而本文则将重点关注一组精心挑选的栈练习题，旨在进一步巩固你的理解和解决问题的能力。

通过对这些练习题的剖析，你将能够掌握栈的基本操作、其在现实世界中的应用，以及如何有效地将栈整合到算法和数据结构的设计中。准备好踏上这段激动人心的学习之旅，揭开栈的奥秘，提升你在数据结构与算法领域的技能吧！

栈练习题剖析

练习题 1：使用数组实现栈

使用顺序存储实现一个栈，并定义压栈、弹栈和获取栈顶元素的操作。

解答：

class Stack {
    private int[] arr;
    private int top;

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

    public void push(int data) {
        if (top == arr.length - 1) {
            throw new StackOverflowError();
        }
        arr[++top] = data;
    }

    public int pop() {
        if (top == -1) {
            throw new EmptyStackException();
        }
        return arr[top--];
    }

    public int peek() {
        if (top == -1) {
            throw new EmptyStackException();
        }
        return arr[top];
    }
}

练习题 2：使用链表实现栈

使用链式存储实现一个栈，并定义压栈、弹栈和获取栈顶元素的操作。

解答：

class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
    }
}

class Stack {
    private Node top;

    public void push(int data) {
        Node newNode = new Node(data);
        newNode.next = top;
        top = newNode;
    }

    public int pop() {
        if (top == null) {
            throw new EmptyStackException();
        }
        int data = top.data;
        top = top.next;
        return data;
    }

    public int peek() {
        if (top == null) {
            throw new EmptyStackException();
        }
        return top.data;
    }
}

练习题 3：反转栈

编写一个函数，将给定栈中的元素反转。

解答：

使用递归，可以轻松地实现栈的反转。

public static void reverseStack(Stack stack) {
    if (!stack.isEmpty()) {
        int data = stack.pop();
        reverseStack(stack);
        insertAtBottom(stack, data);
    }
}

private static void insertAtBottom(Stack stack, int data) {
    if (stack.isEmpty()) {
        stack.push(data);
    } else {
        int temp = stack.pop();
        insertAtBottom(stack, data);
        stack.push(temp);
    }
}

练习题 4：求栈中最小元素

设计一个栈，除了栈的基本操作外，还支持求栈中最小元素的操作。

解答：

可以使用一个辅助栈来跟踪栈中的最小元素。

class MinStack {
    private Stack<Integer> stack;
    private Stack<Integer> minStack;

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

    public void push(int data) {
        stack.push(data);
        if (minStack.isEmpty() || data <= minStack.peek()) {
            minStack.push(data);
        }
    }

    public int pop() {
        int data = stack.pop();
        if (data == minStack.peek()) {
            minStack.pop();
        }
        return data;
    }

    public int getMin() {
        if (!minStack.isEmpty()) {
            return minStack.peek();
        }
        return Integer.MAX_VALUE;
    }
}

练习题 5：利用栈实现括号匹配

给定一个字符串，判断其中是否所有括号都匹配。

解答：

使用一个栈来跟踪打开的括号，并逐个匹配闭合括号。

public static boolean isBalanced(String str) {
    Stack<Character> stack = new Stack<>();
    for (char c : str.toCharArray()) {
        if (isOpenBracket(c)) {
            stack.push(c);
        } else if (isCloseBracket(c)) {
            if (stack.isEmpty() || !isMatchingBracket(stack.pop(), c)) {
                return false;
            }
        }
    }
    return stack.isEmpty();
}

private static boolean isOpenBracket(char c) {
    return c == '(' || c == '{' || c == '[';
}

private static boolean isCloseBracket(char c) {
    return c == ')' || c == '}' || c == ']';
}

private static boolean isMatchingBracket(char open, char close) {
    return (open == '(' && close == ')') || (open == '{' && close == '}') || (open == '[' && close == ']');
}