【数据结构】 - 队列 & 栈

---

theme: smartblue

一、队列

1、概念

队列（Queue）是一种常见的数据结构，它按照先进先出（First In First Out，FIFO）的原则进行元素操作。在队列中，新元素总是被添加到队列的末尾，而从队列中移除元素则是从队列的前端进行操作。

2、主要特点：

1. FIFO原则： 队列中的元素按照它们加入队列的顺序被处理。最先加入队列的元素首先被处理，最后加入的元素则在队列中等待较长的时间。
2. 两个基本操作： 队列支持两个基本操作，即入队（Enqueue）和出队（Dequeue）。入队操作将元素添加到队列的末尾，而出队操作则移除队列的前端元素。
3. 先来先服务： 队列的设计符合“先来先服务”（First-Come-First-Serve，FCFS）的原则，即先到达的任务先被执行，后到达的任务排队等待。

3、基本操作：

1. 入队（Enqueue）： 将新元素添加到队列的末尾。
2. 出队（Dequeue）： 从队列的前端移除元素。
3. 查看队头元素（Front）： 获取队列的前端元素但不移除。
4. 查看队尾元素（Rear）： 获取队列的末尾元素但不移除。
5. 判空（isEmpty）： 检查队列是否为空。
6. 队列大小（Size）： 获取队列中元素的数量。

4、应用场景：

1. 任务调度： 在操作系统中，用于处理进程的任务调度，按照先到先服务的原则。
2. 广度优先搜索： 在图算法中，广度优先搜索时使用队列来管理节点的访问顺序。
3. 缓存： 在计算机系统中，队列常被用于实现缓存，按照FIFO原则管理缓存中的数据。
4. 打印队列： 打印任务按照先到先服务的方式排队等待执行。
5. 消息队列： 在分布式系统中，用于异步通信和事件处理。

5、java实现一个简单的队列

import java.util.LinkedList;

public class QueueExample {
    public static void main(String[] args) {
        // 创建一个整数队列
        Queue<Integer> integerQueue = new Queue<>();

        // 入队操作
        integerQueue.enqueue(1);
        integerQueue.enqueue(2);
        integerQueue.enqueue(3);

        // 出队操作
        System.out.println("Dequeue: " + integerQueue.dequeue());
        System.out.println("Dequeue: " + integerQueue.dequeue());

        // 再次入队
        integerQueue.enqueue(4);

        // 打印队列元素
        System.out.print("Queue: ");
        integerQueue.printQueue();
    }

    static class Queue<T> {
        private final LinkedList<T> list = new LinkedList<>();

        // 入队
        public void enqueue(T item) {
            list.addLast(item);
        }

        // 出队
        public T dequeue() {
            if (isEmpty()) {
                throw new IllegalStateException("Queue is empty");
            }
            return list.removeFirst();
        }

        // 检查队列是否为空
        public boolean isEmpty() {
            return list.isEmpty();
        }

        // 获取队列大小
        public int size() {
            return list.size();
        }

        // 打印队列元素
        public void printQueue() {
            for (T item : list) {
                System.out.print(item + " ");
            }
            System.out.println();
        }
    }
}

LinkedList 实现了一个简单的队列。enqueue 方法用于入队，dequeue 方法用于出队，isEmpty 方法检查队列是否为空，size 方法获取队列大小，printQueue 方法打印队列元素。

二、栈

1、概念

栈（Stack）是一种常见的数据结构，它按照后进先出（Last In First Out，LIFO）的原则进行元素操作。在栈中，新元素总是被添加到栈的顶部，而从栈中移除元素也是从栈顶进行操作。

2、主要特点：

1. LIFO原则： 栈中的元素按照它们加入栈的顺序的相反顺序进行处理。最后加入栈的元素首先被处理，最先加入的元素则在栈中等待较长的时间。
2. 基本操作： 栈支持两个基本操作，即入栈（Push）和出栈（Pop）。入栈操作将新元素添加到栈的顶部，而出栈操作则移除栈顶元素。
3. 限定访问点： 栈是一种限定访问点的数据结构，只能在栈顶进行操作。这意味着只能访问、添加和移除栈顶元素，而不能直接访问栈中的其他元素。

3、基本操作：

1. 入栈（Push）： 将新元素添加到栈的顶部。
2. 出栈（Pop）： 从栈的顶部移除元素。
3. 查看栈顶元素（Top）： 获取栈顶元素但不移除。
4. 判空（isEmpty）： 检查栈是否为空。
5. 栈大小（Size）： 获取栈中元素的数量。

4、应用场景：

1. 函数调用： 在计算机内存中，用于存储函数调用的信息，包括局部变量、返回地址等。
2. 表达式求值： 在编译器中，用于求解表达式的值，实现递归和运算符优先级的处理。
3. 括号匹配： 在编程中，用于检查括号的嵌套是否正确匹配。
4. 浏览器历史记录： 浏览器使用栈来存储用户浏览的页面历史记录。
5. 撤销机制： 许多应用程序使用栈来实现撤销（Undo）操作，以回退用户的操作历史。
6. 深度优先搜索： 在图算法中，深度优先搜索使用栈来管理节点的访问顺序。

5、java实现一个简单的栈

import java.util.LinkedList;

public class StackExample {
    public static void main(String[] args) {
        // 创建一个整数栈
        Stack<Integer> integerStack = new Stack<>();

        // 压栈操作
        integerStack.push(1);
        integerStack.push(2);
        integerStack.push(3);

        // 弹栈操作
        System.out.println("Pop: " + integerStack.pop());
        System.out.println("Pop: " + integerStack.pop());

        // 再次压栈
        integerStack.push(4);

        // 打印栈元素
        System.out.print("Stack: ");
        integerStack.printStack();
    }

    static class Stack<T> {
        private final LinkedList<T> list = new LinkedList<>();

        // 压栈
        public void push(T item) {
            list.addLast(item);
        }

        // 弹栈
        public T pop() {
            if (isEmpty()) {
                throw new IllegalStateException("Stack is empty");
            }
            return list.removeLast();
        }

        // 检查栈是否为空
        public boolean isEmpty() {
            return list.isEmpty();
        }

        // 获取栈大小
        public int size() {
            return list.size();
        }

        // 打印栈元素
        public void printStack() {
            for (T item : list) {
                System.out.print(item + " ");
            }
            System.out.println();
        }
    }
}

LinkedList 实现了一个简单的栈。push 方法用于压栈，pop 方法用于弹栈，isEmpty 方法检查栈是否为空，size 方法获取栈大小，printStack 方法打印栈元素。

总结

一定要多思考，如果人永远待在舒适圈的话，人永远不会成长。共勉。

觉得作者写的不错的，值得你们借鉴的话，就请点一个免费的赞吧！这个对我来说真的很重要。૮(˶ᵔ ᵕ ᵔ˶)ა