栈和队列的区别-优快云博客

本文链接：https://blog.youkuaiyun.com/wls_gk/article/details/141154634

介绍

栈（Stack）和队列（Queue）是两种常用的数据结构，它们有着不同的特点和应用场景。本文将从多个方面探讨栈和队列的区别，包括Java代码实现、实际使用场景、扩展知识以及相关算法参考链接。

区别

1. 数据结构特点

栈是一种后进先出（Last-In-First-Out，LIFO）的线性数据结构。在栈中，最后插入的元素最先被访问。栈的操作包括入栈（push）和出栈（pop）。

队列是一种先进先出（First-In-First-Out，FIFO）的线性数据结构。在队列中，最先插入的元素最先被访问。队列的操作包括入队（enqueue）和出队（dequeue）。

2. Java代码实现

栈的实现

在Java中，栈可以使用数组或链表来实现。以下是使用数组实现的栈的代码示例：

public class Stack {
    private int maxSize;
    private int top;
    private int[] stackArray;

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

    public void push(int value) {
        if (top < maxSize - 1) {
            stackArray[++top] = value;
        } else {
            throw new StackOverflowError("Stack is full");
        }
    }

    public int pop() {
        if (top >= 0) {
            return stackArray[top--];
        } else {
            throw new EmptyStackException();
        }
    }

    public int peek() {
        if (top >= 0) {
            return stackArray[top];
        } else {
            throw new EmptyStackException();
        }
    }

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

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

队列的实现

在Java中，队列可以使用数组或链表来实现。以下是使用数组实现的队列的代码示例：

public class Queue {
    private int maxSize;
    private int front;
    private int rear;
    private int[] queueArray;

    public Queue(int size) {
        maxSize = size;
        queueArray = new int[maxSize];
        front = 0;
        rear = -1;
    }

    public void enqueue(int value) {
        if (rear < maxSize - 1) {
            queueArray[++rear] = value;
        } else {
            throw new QueueOverflowException("Queue is full");
        }
    }

    public int dequeue() {
        if (front <= rear) {
            return queueArray[front++];
        } else {
            throw new EmptyQueueException();
        }
    }

    public int peek() {
        if (front <= rear) {
            return queueArray[front];
        } else {
            throw new EmptyQueueException();
        }
    }

    public boolean isEmpty() {
        return front > rear;
    }

    public boolean isFull() {
        return rear == maxSize - 1;
    }
}

3. 实际使用场景

栈和队列在不同的场景中有着不同的应用。

栈的应用场景

方法调用和递归：在方法调用过程中，每次调用一个方法时将其压入栈，方法执行完毕后再将其弹出，保证方法调用的顺序。
表达式求值：在计算表达式的过程中，使用栈来存储运算符和操作数，根据运算符的优先级进行计算。
括号匹配：使用栈来判断括号的匹配情况，当遇到左括号时将其压入栈，遇到右括号时弹出栈顶元素并进行匹配。

队列的应用场景

消息队列：在分布式系统中，使用队列来进行消息的传递和处理，确保消息的顺序和可靠性。
多线程任务调度：使用队列来存储待执行的任务，并由多个线程从队列中取出任务进行执行。
打印任务队列：在打印机服务中，使用队列来存储待打印的任务，保证打印任务的顺序和公平性。

4. 扩展知识

用栈实现队列

可以使用两个栈来实现队列的功能。一个栈用于入队操作，另一个栈用于出队操作。具体实现如下：

public class MyQueue {
    private Stack<Integer> stack1;
    private Stack<Integer> stack2;

    public MyQueue() {
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    }

    public void enqueue(int value) {
        stack1.push(value);
    }

    public int dequeue() {
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }

    public int peek() {
        if (stack2.isEmpty()) {
            while (!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.peek();
    }

    public boolean isEmpty() {
        return stack1.isEmpty() && stack2.isEmpty();
    }
}

用队列实现栈

可以使用两个队列来实现栈的功能。一个队列用于入栈操作，另一个队列用于出栈操作。具体实现如下：

public class MyStack {
    private Queue<Integer> queue1;
    private Queue<Integer> queue2;
    private int topElement;

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }

    public void push(int value) {
        queue1.add(value);
        topElement = value;
    }

    public int pop() {
        while (queue1.size() > 1) {
            topElement = queue1.remove();
            queue2.add(topElement);
        }
        int result = queue1.remove();
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;
        return result;
    }

    public int top() {
        return topElement;
    }

    public boolean isEmpty() {
        return queue1.isEmpty() && queue2.isEmpty();
    }
}

5. 相关算法参考链接

总结

本文从栈和队列的特点、Java代码实现、实际使用场景以及扩展知识等方面介绍了栈和队列的区别。栈适用于后进先出的场景，例如方法调用和括号匹配；队列适用于先进先出的场景，例如多线程任务调度和消息队列。同时，我们还介绍了如何用栈实现队列、用队列实现栈，并提供了相关算法参考链接供读者进一步深入学习。希望本文能对读者理解栈和队列的区别有所帮助。