深入理解基本数据结构：栈详解

news2024/10/8 14:16:59

引言

在计算机科学中，数据结构是存储、组织和管理数据的方式。栈是一种重要的线性数据结构，广泛应用于各种编程场景。在这篇博客中，我们将详细探讨栈的定义、特点、操作及其在不同编程语言中的实现。

什么是栈？

**栈（Stack）**是一种线性数据结构，遵循后进先出（LIFO, Last In First Out）原则。栈中的元素只能从一端进行添加或删除，这一端被称为栈顶。

栈的特点

后进先出：最新添加的元素最先被移除。
操作受限：只允许在栈顶进行插入和删除操作。
动态大小：栈的大小可以根据需要动态调整。
存储方式：可以使用数组或链表来实现。

栈的基本操作

入栈（Push）：将元素添加到栈顶。
出栈（Pop）：将栈顶元素移除。
查看栈顶元素（Peek/Top）：获取栈顶元素的值，但不移除它。
检查栈是否为空（IsEmpty）：判断栈中是否有元素。

栈的实现

Java中栈的实现

import java.util.EmptyStackException;

public class Stack {
    private Node top;
    private int size;

    private class Node {
        int data;
        Node next;

        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    public Stack() {
        this.top = null;
        this.size = 0;
    }

    // 入栈操作
    public void push(int data) {
        Node newNode = new Node(data);
        newNode.next = top;
        top = newNode;
        size++;
    }

    // 出栈操作
    public int pop() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        int data = top.data;
        top = top.next;
        size--;
        return data;
    }

    // 查看栈顶元素
    public int peek() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        return top.data;
    }

    // 检查栈是否为空
    public boolean isEmpty() {
        return top == null;
    }

    // 获取栈的大小
    public int getSize() {
        return size;
    }

    // 打印栈中的元素
    public void printStack() {
        Node current = top;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        System.out.print("栈中的元素: ");
        stack.printStack();
        System.out.println("栈顶元素: " + stack.peek());
        System.out.println("出栈元素: " + stack.pop());
        System.out.print("出栈后的栈: ");
        stack.printStack();
        System.out.println("栈是否为空: " + stack.isEmpty());
        System.out.println("栈的大小: " + stack.getSize());
    }
}

图解：栈的基本操作

入栈（Push）

出栈（Pop）

查看栈顶元素（Peek/Top）

检查栈是否为空（IsEmpty）

栈的实际应用

反向字符串

利用栈的后进先出特性，可以很容易地反向一个字符串。

public class ReverseString {
    public static String reverse(String str) {
        Stack stack = new Stack();
        for (char c : str.toCharArray()) {
            stack.push(c);
        }
        StringBuilder reversed = new StringBuilder();
        while (!stack.isEmpty()) {
            reversed.append((char) stack.pop());
        }
        return reversed.toString();
    }

    public static void main(String[] args) {
        String str = "Hello, World!";
        System.out.println("原始字符串: " + str);
        System.out.println("反向字符串: " + reverse(str));
    }
}

括号匹配

利用栈可以轻松实现括号匹配的算法，判断一个字符串中的括号是否成对出现。

import java.util.Stack;

public class ParenthesesMatching {
    public static boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (char c : s.toCharArray()) {
            if (c == '(' || c == '{' || c == '[') {
                stack.push(c);
            } else {
                if (stack.isEmpty()) {
                    return false;
                }
                char top = stack.pop();
                if ((c == ')' && top != '(') || (c == '}' && top != '{') || (c == ']' && top != '[')) {
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }

    public static void main(String[] args) {
        String s1 = "{[()]}";
        String s2 = "{[(])}";
        System.out.println(s1 + " 是否匹配: " + isValid(s1));
        System.out.println(s2 + " 是否匹配: " + isValid(s2));
    }
}