数据结构之队列（一般队列）

合集 - 数据结构与算法(24)

1.算法衡量优劣之时间复杂度2023-09-052.数据结构与算法之概念2023-09-013.算法衡量优劣之空间复杂度2023-09-064.数据结构之数组2023-09-065.数据结构之链表2023-09-116.数据结构之栈2023-09-147.N-皇后问题2023-09-198.算术表达式的表示法（即求值法）2023-09-249.算术表达式求值法（表达式求值）之前序表示法求值2023-09-2510.算术表达式求值法（表达式求值）之后序表示法求值2023-09-27

11.数据结构之队列（一般队列）2023-10-08

12.数据结构之队列（循环队列）2023-10-1113.数据结构之队列（双向队列）2023-10-1414.数据结构之树（基本概念）2023-10-2415.数据结构之树（二叉树）2023-10-2916.数据结构之树（Huffman tree(赫夫曼树 / 霍夫曼树 / 哈夫曼树 / 最优二叉树)）2023-10-3117.数据结构之树（二叉树的存储方式之数组）2023-11-0218.数据结构之树（二叉树的存储方式之链表）2023-11-0519.数据结构之树（遍历）2023-11-0520.数据结构之树（二叉运算树）2023-11-0721.数据结构之树（二叉搜索树）2023-11-0822.数据结构之树（线索树）2023-11-1123.数据结构之树（树转化为二叉树也叫二叉化）2023-11-1224.确定唯一二叉树2023-11-12

收起

1. 什么是队列？

队列是一种特殊的线性表，一般只允许在队列的两端进行操作，队列前端进行删除操作，队列的末尾进行添加操作（双向队列的前端、末尾都可以进行删除、添加操作）。

队列可以用数组或链表实现。主要有两个指针：一个front指向队首元素，一个rear指向队尾元素。

 

 

 2. 队列常见操作

 

队列常用的操作有：

• enqueue(e): 将元素e加入队尾
• dequeue(): 返回队首元素，并将其从队列中移除
• peek(): 返回队首元素的值，但不删除
• size():返回队列中元素的个数
• isEmpty(): 队列是否为空
• show(): 返回队列的字符串形式

 

3. 队列的特点

·1. 线性数据结构

 2. 先进先出

 3. 有两个指针：一个front指向队首元素，一个rear指向队尾元素

 4. 一般队首进行出列，队尾进行入列

 5. 队列的长度是动态变化的，可以根据需要自动扩容或者缩减（特别注意数组实现队列时，可能会越界，需要扩容或缩进）。

 

4. 应用场景

队列是一种具有先进先出（FIFO）特性的数据结构，常用于需要按顺序处理数据的场景。以下是一些使用队列的示例：

1. 消息队列：在消息系统中，消息发送者将消息添加到队列的尾部，而消息接收者从队列的头部获取消息进行处理。这种方式可以实现消息的异步处理，提高系统的并发能力。

2. 请求排队：在服务器端，当有大量请求同时达到时，通过队列来对请求进行排队处理，以避免服务器过载。

3. 生产者-消费者模型：在多线程或分布式系统中，生产者负责生成数据，消费者负责处理数据。通过队列作为缓冲区，可以实现生产者和消费者之间的解耦，提高系统的稳定性和性能。

4. 广度优先搜索：在图论算法中，广度优先搜索通过队列来管理待访问的节点，实现对图的层次遍历。这在寻找最短路径等问题中非常常见。

5. 缓存淘汰策略：在缓存系统中，当缓存空间不足时，可以使用队列来记录每个缓存项的访问时间，按照一定的策略删除最早访问的缓存项，以腾出空间给新的缓存项。

6. 系统任务调度：在操作系统中，任务调度器可以使用队列来管理各个进程的执行顺序，按照优先级等规则进行调度。

7. 打印机队列：打印机作为共享资源，当多个任务需要打印时，可以通过队列管理打印请求的顺序，避免打印机被多个任务同时访问。

总之，队列在很多需要按照顺序处理数据的场景中都有应用，它能够提供高效的插入和删除操作，并且保证元素的顺序性。

 5. Python

5.1 数组实现队列

'''
数组实现队列
'''


class Queue:
    def __init__(self):
        self.items = []

    def is_empty(self):
        # 返回队列是否为空
        return self.items == []

    def enqueue(self, item):
        # 在队尾添加元素
        self.items.append(item)

    def dequeue(self):
        # 删除队首元素
        if not self.is_empty():
            return self.items.pop(0)

    def peek(self):
        # 获取队首元素的值
        if not self.is_empty():
            return self.items[0]

    def size(self):
        # 获取队列中的元素个数
        return len(self.items)

    def __str__(self):
        return str(self.items)


myQueue = Queue()
myQueue.enqueue(1)
myQueue.enqueue(2)

print(myQueue.is_empty())  # 返回 False
print(myQueue.peek())  # 返回 1
print(myQueue.peek())  # 返回 1

print(myQueue.dequeue())  # 1
print(myQueue.dequeue())  # 2
print(myQueue.is_empty())  # 返回 True

输出：

?

1 2 3 4 5 6

False 1 1 1 2 True

　　

5.2 链表实现队列示例

'''
链表实现队列
'''


class Node():
    def __init__(self, data):
        self.data = data
        self.next = None


class Queue():
    def __init__(self):
        self.head = None
        self.tail = None

    def enqueue(self, item):
        if self.is_empty():  # 队列为空
            self.head = Node(item)
            self.tail = self.head
        else:  # 队列不为空
            node = Node(item)  # 创建一个节点
            self.tail.next = node  # 把新节点接到尾部
            self.tail = node  # 更新尾部指针

    def dequeue(self):

        if self.is_empty():  # 当队列为空时，返回None
            return None
        else:
            cur = self.head
            self.head = cur.next  # 删除第一个节点
            if self.head is None:  # 如果删除后队列已经空了
                self.tail = None
            return cur

    def is_empty(self):
        return self.head is None


myQueue = Queue()
print(myQueue.is_empty())  # True
myQueue.enqueue(1)
myQueue.enqueue(2)
print(myQueue.is_empty())  # 返回 False
print(myQueue.dequeue().data)  # 返回 1
print(myQueue.dequeue().data)  # 返回 2
print(myQueue.is_empty())  # 返回 True

输出：

?

1 2 3 4 5

True False 1 2 True

　

6. Java

　

在Java中，可以使用数组来实现队列。具体实现的方式有以下几种：

1. 使用固定长度的数组：可以创建一个固定长度的数组，然后使用指针指向队列的头部和尾部。当入队操作时，将元素添加到队列尾部，同时移动尾指针。当出队操作时，将头指针指向的元素删除，并将头指针向后移动一位。这种方式的缺点是队列的长度固定，不能动态调整。

2. 使用循环数组：可以创建一个循环数组，使用两个指针分别指向队列的头部和尾部。当入队操作时，将元素添加到尾部，并将尾指针向后移动一位，如果尾指针超过了数组的长度，则将其重置为0。当出队操作时，将头指针指向的元素删除，并将头指针向后移动一位，如果头指针超过了数组的长度，则将其重置为0。这种方式可以实现队列的动态扩容。

3. 使用LinkedList类：Java提供了LinkedList类，可以直接用来实现队列。LinkedList类实现了Queue接口，提供了队列的常见操作方法，如入队、出队、获取队首元素等。使用LinkedList类实现队列的好处是不需要手动处理数组的大小和扩容问题，同时具有较好的插入和删除性能。

import java.util.LinkedList;
import java.util.Queue;

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

        // 入队操作
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);

        // 出队操作
        int firstElement = queue.poll();
        System.out.println("出队元素：" + firstElement);

        // 获取队首元素（不出队列）
        int frontElement = queue.peek();
        System.out.println("队首元素：" + frontElement);

        // 获取队列中的元素个数
        int size = queue.size();
        System.out.println("队列大小：" + size);

        // 打印队列
        System.out.println("队列内容：" + queue);
    }
}

输出：

?

1 2 3 4

出队元素：1 队首元素：2 队列大小：2 队列内容：[2, 3]