解剖栈和队列：Java数据结构的灵魂

2023-10-08 23:37:28

栈和队列：计算机科学基石

在计算机科学的浩瀚世界中，数据结构犹如建筑物的基石，支撑着整个软件系统的运作。今天，我们将聚焦于两种最基本也是最重要的数据结构：栈和队列。它们如同编程语言的字母表，是构建复杂程序的基础。让我们一起踏上探索之旅，深入剖析栈和队列的奥秘，并揭示它们在Java世界中的广泛应用。

栈

想象一下一摞盘子，当您添加或移除盘子时，总是从最上面的一块开始。这就是栈（Stack）的工作原理。栈遵循先进后出（LIFO）的原则，也就是说，最后进入栈中的元素将最先被移除。

实现栈

栈可以用数组或链表来实现：

数组实现： 简单易行，但存在空间浪费的问题。
链表实现： 更加灵活，但会带来一些性能开销。

// 使用数组实现栈
class StackUsingArray {
    private int[] arr;
    private int top;

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

    // 入栈
    public void push(int data) {
        if (top == arr.length - 1) {
            System.out.println("栈已满");
            return;
        }
        arr[++top] = data;
    }

    // 出栈
    public int pop() {
        if (top == -1) {
            System.out.println("栈已空");
            return -1;
        }
        return arr[top--];
    }
}

// 使用链表实现栈
class StackUsingLinkedList {
    private Node head;

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

    public int pop() {
        if (head == null) {
            System.out.println("栈已空");
            return -1;
        }
        int data = head.data;
        head = head.next;
        return data;
    }
}

队列

想象一下银行里的队伍，人们按照先到先服务的原则排队。这就是队列（Queue）的工作原理。队列遵循先进先出（FIFO）的原则，也就是说，最早进入队列的元素将最先被移除。

实现队列

队列可以用数组或循环缓冲区来实现：

数组实现： 简单易行，但存在空间浪费的问题。
循环缓冲区实现： 更加高效，但也需要考虑边界情况。

// 使用数组实现队列
class QueueUsingArray {
    private int[] arr;
    private int front, rear;

    public QueueUsingArray(int size) {
        arr = new int[size];
        front = rear = -1;
    }

    // 入队
    public void enqueue(int data) {
        if ((rear + 1) % arr.length == front) {
            System.out.println("队列已满");
            return;
        }
        if (front == -1) {
            front++;
        }
        rear = (rear + 1) % arr.length;
        arr[rear] = data;
    }

    // 出队
    public int dequeue() {
        if (front == -1) {
            System.out.println("队列已空");
            return -1;
        }
        int data = arr[front];
        if (front == rear) {
            front = rear = -1;
        } else {
            front = (front + 1) % arr.length;
        }
        return data;
    }
}

// 使用循环缓冲区实现队列
class QueueUsingCircularBuffer {
    private int[] arr;
    private int head, tail;

    public QueueUsingCircularBuffer(int size) {
        arr = new int[size];
        head = tail = -1;
    }

    // 入队
    public void enqueue(int data) {
        if ((tail + 1) % arr.length == head) {
            System.out.println("队列已满");
            return;
        }
        if (head == -1) {
            head++;
        }
        tail = (tail + 1) % arr.length;
        arr[tail] = data;
    }

    // 出队
    public int dequeue() {
        if (head == -1) {
            System.out.println("队列已空");
            return -1;
        }
        int data = arr[head];
        if (head == tail) {
            head = tail = -1;
        } else {
            head = (head + 1) % arr.length;
        }
        return data;
    }
}