数据结构之队列

最新推荐文章于 2023-07-29 21:18:50 发布
最新推荐文章于 2023-07-29 21:18:50 发布
阅读量265 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48842132/article/details/125450270
版权

1. 什么是队列❓

排队买票的队伍，就是一个队列。先来的先买，后来的只能站末尾，不能插队。
特点：先进者先出
同栈一样，是一种操作受限的线性表数据结构

2. 何时使用队列❓

例：当我们向一个固定大小的线程池请求一个线程时，此时线程池没有资源，但是我们又不想拒绝掉这次请求，这时候就会用到队列。
具体策略：将请求排队，等到有空闲线程时，取出排队的请求继续处理。

3. 队列的关键操作

  • 入队enqueue()：放一个数据到队列尾部
  • 出队dequeue()：从队列头部取一个元素

4. 队列的种类

  • 按实现方式分为：顺序队列(用数组实现)和链式队列(用链表实现)
  • 按队列结构分为：一般队列、循环队列、阻塞队列、并发队列等

5. 一般队列的实现

5.1 顺序队列

需要用到两个指针，一个是队头head，一个是队尾tail
关键：数据搬移(为了重新利用起之前申请到的空间)

Java代码：

public class ArrayQueue {
    // 数组：items，数组大小：n
    private String[] items;
    private int n = 0;
    // head表示队头下标，tail表示队尾下标
    private int head = 0;
    private int tail = 0;
    // 申请一个大小为capacity的数组
    public ArrayQueue(int capacity){
        items = new String[capacity];
        n = capacity;
    }
    // 入队
    public boolean enqueue(String item){
        if (tail == n){
            if (head == 0) return false;
            // 数据搬运
            for (int i = head; i < tail; ++ i)
            {
                items[i - head] = items[i];
            }
            tail = tail - head;
            head = 0;
        }
        items[tail] = item;
        ++ tail;
        return true;
    }
    // 出队
    public String dequeue(){
        if (head == tail) return null; // 队头指针与队尾指针相等，表示队列为空
        String ret = items[head];
        ++ head;
        return ret;
    }
}

C++代码：

#include <iostream>
#include <string>
using namespace std;
class ArrayQueue
{
	public:
		ArrayQueue(int capacity); // 申请数组 
		bool enqueue(string item); // 入队 
		string dequeue(); // 出队 
	private:
		int n;
		string* items;
		int head = 0;
		int tail = 0;
}; 
ArrayQueue::ArrayQueue(int capacity){
	items = new string[capacity];
	n = capacity;
}
bool ArrayQueue::enqueue(string item){
	if (tail == n) {
		if (head == 0) return false; // 队满
		for (int i = head; i < tail; ++ i){ // 数据搬运 
			items[i - head] = items[i]; 
		} 
		tail = tail - head;
		head = 0;
	} 
	items[tail] = item;
	++ tail;
	return true;
}
string ArrayQueue::dequeue(){
	if (head == tail) return "This queue is empty!";
	string ret = items[head];
	++ head;
	return ret;
} 
int main(void)
{
	ArrayQueue myQueue(3);
	myQueue.enqueue("zhangsan");
	myQueue.enqueue("lisi");
	myQueue.enqueue("wangwu");
	cout << "插入第四个元素结果：" <<myQueue.enqueue("add") << endl; // 多插一个测试失败结果
	for (int i = 0; i < 4; ++ i){
		cout << myQueue.dequeue() << endl;
	} 
}

Python代码：

from typing import Optional
class ArrayQueue:
    def __init__(self, capacity: int):
        self.__items = [0 for i in range(capacity)]
        self.__n = capacity
        self.__head = 0
        self.__tail = 0
    def enqueue(self, item: str) -> bool:
        if self.__tail == self.__n:
            if self.__head == 0: # 队列已满 
                return False
            # 充分利用空间，进行数据搬运
            for i in range(self.__head, self.__tail):
                self.__items[i - self.__head] = self.__items[i]
            self.__tail = self.__tail - self.__head
            self.__head = 0
        self.__items[self.__tail] = item
        self.__tail = self.__tail + 1
        return True
    def dequeue(self) -> Optional[str]:
        if (self.__head == self.__tail): 
            return None
        item = self.__items[self.__head]
        self.__head = self.__head + 1
        return item

q = ArrayQueue(3)
q.enqueue(3)
q.enqueue(2)
q.enqueue(1)
print(q.enqueue(0)) # 数量上限，故插入失败
print(q.dequeue()) # 将元素3弹出，给元素0腾位置
print(q.enqueue(0))
print(q.dequeue())
print(q.dequeue())
print(q.dequeue())
print(q.dequeue()) # 队列为空情况

5.2 链式队列

两个指针：head指向链表的第一个结点，tail指向链表的最后一个结点
关键：入队时tail->next = new_node, tail = tail->next；出队时head = head->next

Java代码：

public class LinkedListQueue {
    private Node head = null;
    private Node tail = null;
    private int n = 0;
    private int capacity = 0;

    public LinkedListQueue(int capacity){
        this.n = capacity;
    }
    // 入队
    public boolean enqueue(String item){
        if (capacity == n) return false;
        Node node = new Node(item, null);
        if (capacity == 0){
            tail = node;
            head = node;
        }
        else {
            tail.setNext(node);
            tail = tail.getNext();
        }
        ++capacity;
        return true;
    }
    // 出队
    public String dequeue(){
        if (head != null)
        {
            --capacity;
            String ret = head.getData();
            head = head.getNext();
            return ret;
        }else return null;
    }



    private class Node{
        private String data;
        private Node next;
        public Node(String data, Node next){
            this.data = data;
            this.next = next;
        }

        public void setNext(Node next){
            this.next = next;
        }

        public String getData(){
            return data;
        }
        public Node getNext(){
            return next;
        }
    }
}

C++代码：

#include <iostream>
#include <string>
using namespace std;

struct Node
{
	Node* next;
	string data;
	Node(string data){
		this->data = data;
		this->next = NULL;
	}
};

struct LinkedListQueue
{
	Node* head;
	Node* tail;
	int n;
	int capacity;
	LinkedListQueue(int capacity)
	{
		this->n = capacity;
		this->capacity = 0; 
		head = NULL;
		tail = NULL;
	};
	bool enqueue(string item){
		if (capacity == n) return false;
		Node* node = new Node(item);
		if (capacity == 0){
			tail = node;
			head = node;
		}else{
			tail->next = node;
			tail = tail->next;
		}
		++capacity;
		return true;
	}; 
	string dequeue(){
		if (head == NULL)
		{
			return "This queue is empty!"; 
		}
		else
		{
			--capacity;
			string ret = head->data;
			head = head->next;
			return ret;
		}
	}
};


int main(void)
{
	LinkedListQueue* myQueue = new LinkedListQueue(3);
	myQueue->enqueue("zhangsan");
	myQueue->enqueue("lisi");
	myQueue->enqueue("wangwu");
	cout << myQueue->enqueue("add") << endl; // 多加一个 
	for (int i = 0; i < 3; ++ i) cout << myQueue->dequeue() << endl;
	cout << myQueue->dequeue() << endl;
	cout << myQueue->enqueue("add") << endl; 
	cout << myQueue->dequeue() << endl;
	return 0;
}

Python代码：

from typing import Optional
class Node:
    def __init__(self, data: str):
        self.__data = data
        self.__next = None
    def setNext(self, next):
        self.__next = next
    def getNext(self):
        return self.__next
    def setData(self, data: str):
        self.__data = data
    def getData(self) -> str:
        return self.__data

class LinkedListQueue:
    def __init__(self, capacity: int):
        self.__n = capacity
        self.__capacity = 0
        self.__head = None
        self.__tail = None
    def enqueue(self, item: str) -> bool:
        if self.__capacity == self.__n:
            return False
        node = Node(item)
        if self.__capacity == 0: # 队列为空
            self.__tail = node
            self.__head = node
        else:
            self.__tail.setNext(node)
            self.__tail = self.__tail.getNext()
        self.__capacity = self.__capacity + 1
        return True
    def dequeue(self) -> Optional[str]:
        if self.__capacity == 0:
            return None
        else:
            data = self.__head.getData()
            self.__head = self.__head.getNext()
            self.__capacity = self.__capacity - 1
            return data

6. 循环队列

循环队列
图源：王争 数据结构与算法之美

好处：免去了在使用数组实现队列时，当tail==n时的数据搬移操作，提高了入队操作性能
实现难点：队空(head = tail)和队满判断条件((tail+1)%n = head)
小小缺点：当队列满时，tail指向的位置实际上没有存储数据，会浪费一个存储空间

Java代码：

public class CircularQueue {
    private String []items;
    private int n = 0;
    private int head = 0;
    private int tail = 0;
    public CircularQueue(int capacity){
        items = new String[capacity];
        n = capacity;
    }
    // 入队
    public boolean enqueue(String item){
        if ((tail + 1) % n == head) return false;
        items[tail] = item;
        tail = (tail + 1) % n;
        return true;
    }
    // 出队
    public String dequeue(){
        if (head == tail) return null; // 队列为空
        String ret = items[head];
        head = (head + 1) % n;
        return ret;
    }
}

C++代码：

#include <iostream>
#include <string>

using namespace std;
class CircularQueue
{
	public:
		CircularQueue(int capacity);
		bool enqueue(string item);
		string dequeue();
	private:
		int n;
		string* items;
		int head = 0;
		int tail = 0;
}; 
CircularQueue::CircularQueue(int capacity){
	items = new string[capacity];
	n = capacity;
} 
bool CircularQueue::enqueue(string item){ 
	if ((tail + 1) % n == head) return false; // 队满
	items[tail] = item;
	tail = (tail + 1) % n;
	return true; 
}
string CircularQueue::dequeue(){
	if (head == tail) return "This queue is empty!";
	string ret = items[head];
	head = (head + 1) % n;
	return ret;
}



int main(void)
{
	CircularQueue myQueue(3);
 	myQueue.enqueue("zhangsan");
 	myQueue.enqueue("lisi");
 	cout << myQueue.enqueue("wangwu") << endl;
 	for (int i = 0; i < 3; ++ i){
 		cout << myQueue.dequeue() << endl;
 	} 
	cout << myQueue.enqueue("add") << endl;
	cout << myQueue.dequeue() << endl;
	
	return 0;
}

Python代码：

from typing import Optional
class CircularQueue:
    def __init__(self, capacity: int):
        self.__items = [0 for i in range(capacity)]
        self.__n = capacity
        self.__head = 0
        self.__tail = 0
    def enqueue(self, item: str) -> bool:
        if (self.__tail + 1) % self.__n == self.__head:  # 队满
            return False
        self.__items[self.__tail] = item
        self.__tail = (self.__tail + 1) % self.__n
        return True
    def dequeue(self) -> Optional[str]:
        if self.__head == self.__tail:
            return None
        ret = self.__items[self.__head]
        self.__head = (self.__head + 1) % self.__n
        return ret

7. 其他

  • 阻塞队列：队列为空时，取数据的操作会被阻塞，队列满时，插入数据的操作会被阻塞。可以用于实现生产者-消费者模型
  • 并发队列：一种线程安全的队列

8. END

愿我们都有诗和远方 😀

诗和远方

小陌白
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
transformer学习之多头注意力机制
MyHeartWillGoOn
12-30 1万+
文章目录题目注意力机制多头注意力机制为什么要使用多头注意力机制 题目 transformer学习之多头注意力机制 注意力机制 详细了解 ➡️ 注意力机制 之前我们也学习过了Seq2Seq，知道了把注意力机制加入到它后会使模型学习的更有效率，那么现在到了全部都由注意力机制构成的Transformer，它和Seq2Seq中加入的注意力有什么不同呢？ 不同点 Seq2Seq里的Attention Transformer s(Q,K)=QTKs(Q,K)=Q^TKs(Q,K)=QTK s(Q,K)=
Java数据结构之队列的简单定义与使用方法
08-29
主要介绍了Java数据结构之队列的简单定义与使用方法,简单描述了队列的功能、特点,并结合java实例形式分析了队列的简单定义与使用方法,需要的朋友可以参考下
【数据结构】队列详解
fighting小泽的博客
05-19 2182
🌸作者简介：目前正在学习C语言和数据结构。
高能技巧！60 行 NumPy 代码 从头实现一个 GPT
CSDN资讯
02-15 1189
【CSDN 编者按】近日，一名工程师 Jay Mody 在一篇文章汇总将用 60 行 NumPy 代码从头实现一个 GPT。并把 GPT-2 模型权重加载到实现中，从而生成文本。原文链接：https://jaykmody.com/blog/gpt-from-scratch/未经授权，禁止转载！作者 | JayMody 译者| 禾木木出品 | CSDN（ID：CSDNnews）在本篇文...
【数据结构】队列（Queue）的实现 -- 详解
Elena's Blog
07-29 1301
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有：进行操作的一端称为。：进行操作的一端称为。
【数据结构】带你深度理解队列
忆梦初心的博客
04-01 2319
与栈同理，队列也是一种限制型的数据结构，不支持随机访问。其只允许在固定的两端进行操作。因此也不存在查找，打印，修改等需要对其他位置进行操作的接口，否则会破坏队列的特性。数据结构的实现方式多种多样，为了在隐藏设计细节的情况下使用方依旧能够很方便的使用，尽管有一些操作仅仅只有一两行代码，我们还是封装成函数作为对外的接口供使用方调用。
数据结构之队列的java实现
12-22
队列也是一种数据结构，类似于栈，只是与栈相反，在队列中先插入的数据也先被移除，即先进先出(FIFO，First In First Out)。队列可以理解成排队，比如，食堂窗口排的队，越在前面的，越早得到服务而先离开。在银行...
数据结构之队列.rar
04-07
数据结构之队列数据结构之队列数据结构之队列数据结构之队列数据结构之队列数据结构之队列数据结构之队列数据结构之队列数据结构之队列
数据结构-使用javascript讲解数据结构之队列.zip
最新发布
02-12
数据结构 数据结构_使用javascript讲解数据结构之队列
数据结构之队列（Java版）
01-21
1.队列概述：队列是一个有序表，可以用数组或链表实现（本篇讲的是用数组实现），遵循先入先出（FIFO）原则，即先存入队列的数据，要先取出，后存入的要后取出。 2.用数组实现队列的思路 使用数组的声明如下图，其中...
数据结构韩顺平版（2）
qq_24573381的博客
04-08 190
队列 1.队列的一个使用场景 银行排队的案例: 2、队列介绍 1) 队列是一个有序列表，可以用数组或是链表来实现。 2) 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 3) 示意图：(使用数组模拟队列示意图) 3、数组模拟队列思路 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队 列的最大容量。  因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front 及 ..
数据结构——队列
weixin_57023347的博客
06-11 978
文章目录1.队列定义2.队列表现形式顺序表(数组)链表3.队列主要操作4.队列的代码实现数组：链表 1.队列定义 队列时一种受限制的线性表，只能再一端进行插入，再另外一端进行删除。 就像现实中的排队一样在新来的人排在对尾，拍在队伍前面的人先进行服务后离开，期间不允许插队。 简单介绍： 假如有一个队列，将A,B,C,D插入队列中，对头元素是A，对尾元素是D。也就是说第一个被删除的元素是A，最后一个被删除的元素是D。由此可见，队列具有一个特征，就是先入先出，后入后出。 队列需要两个指针，一个对头指针(fro
数据结构——循环队列
热门推荐
yue152152的博客
03-28 1万+
概念 基于队列的先进先出的原则，在确定了队列长度的前提下，另队列首尾相接而实现的一种结构。 循环队列的作用 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/design-circular-queue 题目 设置循环队列 注意事项 .
【数据结构--队列】
Lyao_Boker的博客
01-27 830
队列队列的逻辑结构顺序队列的存储结构 队列的逻辑结构 队列(queue)是只允许在一端进行插入操作，在另一端进行删除操作的线性表，允许插入(也称入队、进队)的一端称为队尾(queue-tail)，允许删除(也称出队)的一端称为队头(queue-head)。 如图是一个有5个元素的队列，入队的顺序为a1，a2，a3，a4，a5，出队的顺序依然是a1，a2，a3，a4，a5，即最先入队者最先出队。所以队列中的元素除了具有线性关系外，还具有先进先出(first in first out)的特性。 顺序队列的存储
数据结构—队列
想要上进的coder的博客
11-14 1037
一、什么是队列 队列的概念及结构 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头 队列是一种很公平的数据结构，我们可以类比去银行取钱时的排队 二、队列的实现 三、一个简单的小例子 ...
数据结构与算法之队列
努力让自己发光，对的人才能迎着光而来
08-18 1万+
队列概念 队列的操作
数据结构之【队列】
weixin_40989362的博客
08-09 679
队列：先进先出，就是一块线性表，必须从头front的一方出队，从尾巴rear一方入队 我们生活中的队列就是这样的，出队的时候每次必须从a1出队，           当头出队后，尾巴就向前移动到下标为0处，这样的效率太低了，我们应该提高效率，每次头front出队了，就不需要向前移动 队头不需要每次都向前移动 如果front==rear的时候队为空，每次入队一个尾巴就向后面移动...
多头注意力代码解读
简单记录生活、学习
01-14 6932
初始化阶段， 其中要注意的是hid_dim要和Q、K、V词向量的长度相等 import torch from torch import nn class MultiheadAttention(nn.Module): # n_heads：多头注意力的数量 # hid_dim：每个词输出的向量维度 def __init__(self, hid_dim, n_heads, dropout): super(MultiheadAttention, self).__..
数据结构复习队列和栈
07-30
数据结构中的队列和栈是两种常见的数据结构。队列是一种先进先出（FIFO）的数据结构，而栈是一种后进先出（LIFO）的数据结构。 队列的基本概念包括定义和常见基本操作。队列可以使用顺序存储结构或链式存储结构来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小陌白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值