数据结构篇——队列

已于 2023-10-25 17:55:07 修改
阅读量1.1k 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 经验分享 链表 线性回归
于 2023-04-29 19:01:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boke00_7/article/details/130395169
版权

一、仿写代码

        在循环队列中，当队列为空，可知 front=rear；而当所有队列空间全占满时，也有 front=rear。为了区别这两种情况，假设队列使用的数组有 k 个存储空间，size表示队头到队尾的长度，如果size==k则表示队列已满。根据以上可知，队列判空的条件是 front=rear，而队列判满的条件是 size == k。
        对于一个固定大小的数组，只要知道队尾rear 与队首 front，即可计算出队列当前的长度：

                                                (rear−front+k) mod k
循环队列的属性如下:

  • elements：一个固定大小的数组，用于保存循环队列的元素。
  • k：循环队列的容量，即队列中最多可以容纳的元素数量。
  • front：队列首元素对应的数组的索引。
  • rear：队列尾元素对应的索引的下一个索引。

循环队列的接口方法如下：

  • MyCircularQueue(int k): 初始化队列，同时base 数组的空间初始化大小为 k。front,rear 全部初始化为 0。
  • isEmpty()：检测队列是否为空，根据之前的定义只需判断 rear 是否等于front。
  • isFull()：检测队列是否已满，根据之前的定义只需判断 size 是否等于 k。
  • enQueue(int value)：在队列的尾部插入一个元素，并同时将队尾的索引 rear 更新为 (rear+1) mod k。
  • deQueue()：从队首取出一个元素，并同时将队首的索 front 更新为 (front+1) mod k。
  • Front()：返回队首的元素，需要检测队列是否为空。
  • Rear()：返回队尾的元素，需要检测队列是否为空。
  • showQueue()：输出队列所有数据

数组法：

class MyCircularQueue {
	private int front;
	private int rear;
	private int size;
	private int k;
	private int[] elements;
	
	public static void main(String[] args) {
		MyCircularQueue myCircular = new MyCircularQueue(5);
		myCircular.enQueue(3);
		myCircular.enQueue(6);
		myCircular.enQueue(5);
		myCircular.deQueue();
		int a = myCircular.Front();
		int b = myCircular.Rear();
		System.out.println(a);
		System.out.println(b);
		myCircular.showQueue();
	}
	
	// 构造器
	public MyCircularQueue(int k) {
		this.k = k;
		elements = new int[k];
		rear = front = 0;
	}
	
	// 判断队列是否为空
	public boolean isEmpty() {                             
		return rear == front;
	}
		
	// 判断队列是否已满
	public boolean isFull() {                              
		return size == k;
	}
		
	// 在队列尾部插入一个元素
	public boolean enQueue(int value) {                    
		if(isFull()) {
			return false;
		}
		elements[rear] = value;
		rear = (rear + 1)%k;
		size++;
		return true;
	}
	
	// 从队列头部删除一个元素
	public boolean deQueue() {                              
		if(isEmpty()) {
			return false;
		}
		front = (front + 1)%k;
		size--;
		return true;
	}
	
	// 返回头部元素
	public int Front() {                                   
		if(isEmpty()) {
			return -1;
		}
		return elements[front];
	}
	
	// 返回尾部元素
	public int Rear() {                                    
		if(isEmpty()) {
			return -1;
		}
		return elements[(rear-1)%k];
	}
	
	// 显示队列所有数据
	public void showQueue() {
		if(isEmpty()) {
			System.out.println("队列为空，没有值~");
		}
		for(int i = front; i<rear; i++) {
			System.out.println(elements[i]);
		}
	}
}

链表法：

class MyCircularQueue{
	private int k,count;
	public static void main(String[] args) {
		MyCircularQueue myCircularQueue = new MyCircularQueue();
		myCircularQueue.Rear(3);
		myCircularQueue.Rear(5);
		myCircularQueue.Rear(6);
		myCircularQueue.poll();                    // 删除
		int a = myCircularQueue.peek();            // 返回队头
		myCircularQueue.poll();
		int b = myCircularQueue.poll();
		int c = myCircularQueue.peek();
		int d = myCircularQueue.size();            // 返回队列长度
		
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		
	}
	
	public static class Node{
		public int val;
		public Node next;
		
		public Node(int val, Node next) {
			this.val = val;
			this.next = next;
		}
		
		public Node(int val) {
			this.val = val;
		}
	}
	
	public Node head;
	public Node last;
	
	// 尾部插入
	public void Rear(int val) {
		if(head == null) {
			head = new Node(val);
			last = head;
		}else {
			Node cur = new Node(val);
			last.next = cur;
			last = cur;
		}
		
	}
	
	// 从头部删除元素，并返回删除的数
	public int poll() {
		if(head == null || last == null) {
			return -1;
		}
		int val = head.val;
		head = head.next;
		return val;
		
	}
	
	// 返回头部元素，但不删除
	public int peek() {
		if(head == null || last == null) {
			return -1;
		}
		int val = head.val;
		return val;
		
	}
	
	// 队列长度
	public int size() {
		Node cur = head;
		int size = 0;
		while(cur!=null) {
			cur=cur.next;
			size++;
		}
		return size;
	}
}

二、算法题巩固

（1）用两个队列实现栈

类定义：

  • Queue类表示生成队列
  • Stack类表示生成栈

属性定义和方法定义看代码注释

// 创建队列
class Queue {
	private int front;
	private int rear;
	private int size;
	private int k;
	private int[] elements;
	
	// 构造器
	public Queue(int k) {
		this.k = k;
		elements = new int[k];
		rear = front = 0;
	}
	
	// 判断队列是否为空
	public boolean isEmpty() {                             
		return rear == front;
	}
		
	// 判断队列是否已满
	public boolean isFull() {                              
		return size == k;
	}
		
	// 在队列尾部插入一个元素
	public boolean offer(int value) {                    
		if(isFull()) {
			return false;
		}
		elements[rear] = value;
		rear = (rear + 1)%k;
		size++;
		return true;
	}
	
	// 从队列头部删除一个元素
	public int poll() {                              
		if(isEmpty()) {
			return -1;
		}
		int val = elements[front];
		front = (front + 1)%k;
		size--;
		return val;
	}
	
	// 返回头部元素
	public int peek() {                                   
		if(isEmpty()) {
			return -1;
		}
		return elements[front];
	}
	
	// 返回尾部元素
	public int Rear() {                                    
		if(isEmpty()) {
			return -1;
		}
		return elements[(rear-1)%k];
	}
	
	// 显示队列所有数据
	public void showQueue() {
		if(isEmpty()) {
			System.out.println("队列为空，没有值~");
		}
		for(int i = front; i<rear; i++) {
			System.out.println(elements[i]);
		}
	}
}


public class Stack {
	public static void main(String[] args) {
		Stack stack = new Stack();
		stack.push(1);
		stack.push(2);
		int a = stack.top();           // 返回栈顶元素
		stack.pop();                   // 删除并返回栈顶元素
		int b = stack.pop();
		System.out.println(a);
		System.out.println(b);
		System.out.print(stack.empty());
	}
	
	// 创建两个长度为5的队列对象
	Queue m1;
	Queue m2;
	
	public Stack() {
		m1 = new Queue(5);
		m2 = new Queue(5);
	}
	
	// 向栈中添加元素
	public void push(int val) {
		m2.offer(val);
		while(!m1.isEmpty()) {
			m2.offer(m1.poll());
		}
		Queue temp = m1;
		m1 = m2;
		m2 = temp;
	}
	
	// 移除并返回栈顶元素
	public int pop() {
		return m1.poll();
	}
	
	// 返回栈顶元素
	public int top() {
		return m1.peek();
	}
	
	// 判断栈是否为空
	public boolean empty() {
		return m1.isEmpty();
	}
	
}

（2）用单队列实现栈

public class Stack {
	public static void main(String[] args) {
		Stack stack = new Stack();
		stack.push(1);
		stack.push(2);
		int a = stack.top();           // 返回栈顶元素
		stack.pop();                   // 删除并返回栈顶元素
		int b = stack.pop();
		System.out.println(a);
		System.out.println(b);
		System.out.print(stack.empty());
	}
	
	// 创建两个长度为5的队列对象
	Queue m1;
	
	public Stack() {
		m1 = new Queue(5);
	}
	
	// 向栈中添加元素
	public void push(int val) {
		int n = m1.Size();
		m1.offer(val);
		// 单个队列实现栈
		for(int i = 0; i < n; i++) {
			m1.offer(m1.poll());
		}
	}
	
	// 移除并返回栈顶元素
	public int pop() {
		return m1.poll();
	}
	
	// 返回栈顶元素
	public int top() {
		return m1.peek();
	}
	
	// 判断栈是否为空
	public boolean empty() {
		return m1.isEmpty();
	}
	
}

小小修士
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构实验——队列子系统
07-31
设计一个字符型的链队列；编写队列的进队、出队、读队头元素、显示队列中全部元素程序；设计一个选择式菜单，以菜单方式选择队列的各种基本操作。
Python 中判断列表是否为空的方法
09-18
主要介绍了Python 中判断列表是否为空的方法，本文通过代码详解的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
环形队列，用front和rear作为对头和队尾指针，tag表示队列是空还是不空
10-13
设计一个环形队列，用front和rear分别作为队头和队尾指针，另外用一个tag表示队列是空（0）还是不空（1），这样就可以用front==rear作为堆满的条件。要求设计队列相关基本运算算法。 数据结构上机作业 第二章15题 张宪超
hb-zhyu的模拟队列
最新发布
01-23
实现一个队列，队列初始为空，支持四种操作： push x – 向队尾插入一个数 xx； pop – 从队头弹出一个数； empty – 判断队列是否为空； query – 查询队头元素。 现在要对队列进行 MM 个操作，其中的每个操作 3 和操作 4 都要输出相应的结果。 输入格式 第一行包含整数 M，表示操作次数。 接下来 M 行，每行包含一个操作命令，操作命令为 push x，pop，empty，query 中的一种。 输出格式 对于每个 empty 和 query 操作都要输出一个查询结果，每个结果占一行。 其中，empty 操作的查询结果为 YES 或 NO，query 操作的查询结果为一个整数，表示队头元素的值。 数据范围 1≤M≤100000, 1≤x≤109, 所有操作保证合法。
Python-数组实现循环队列和非循环队列
12-22
什么是队列？  队列就是只能在一端插入，而在另一端删除的线性表，故队列又称为先进先出队列 队列类型有哪些？ 循环队列和顺序队列  队列的存储实现方式有哪些？ 顺序存储（数组）和链式存储（链表），此博文描述的是数组的实现（后续更新链表实现）  代码实现 初始化队列：初始化一个size长度的队列，队列的值都为0 判断队列是否已满：队列满，不可插入队列 判断队列是否为空：队列空，没有数据可以出队 入队：将数据item插入队列 出队：将对头元素从队列中删除并返回的值 class Queue: """非循环队列""" def __init__(self, size):
数据结构 队列
yanglq的博客
08-22 1728
1 顺序循环队列 Q 空的条件是： Q.front==Q.rear. 为了方便起见，约定：初始化建空队时，令       front=rear=0,   当队空时：front=rear   当队满时：front=rear 亦成立   因此只凭等式front=rear无法判断队空还是队满。  有两种方法处理上述问题：     （1）另设一个标志位以区别队列是空还是满。     
数据结构练习——运算标志来判断队列空满
m0_61139799的博客
04-30 1559
【题目描述】 如果对循环队列采用设置运算标志的方法来区分队列的满和空的状态，试给出对应的各运算的实现。 【算法描述】 这里需要设置一个标志变量tag，当front=rear，且tag=0时队列为队列空，当front=rear，且tag=1时为队列满！ 代码实现如下： #include <iostream> using namespace std; #define MAXSIZE 6 typedef int QElemType; typedef struct { QElemT
（图解）循环队列的三种判断队空、队满操作（附带源码和插入删除操作等一些基本操作）
在夜里行走的博客
10-15 2万+
一万字图解循环队列附带测试程序的源码
队列的基本操作 出队 入队 判断队列是否为空 .......
weixin_45220224的博客
10-30 4781
#include <stdio.h> #include <malloc.h> #include<stdlib.h> #define MAXQSIZE 100 //最大队列长度，实际使用 MAXQSIZE-1 #define OVERFLOW 0 typedef int ElemType; typedef int Status; //循环队列(少用一个存储单元) typedef struct { ElemType base[MAXQSIZE];//初始化的动态分配存储空间
【数据结构】队列
qq_45004609的博客
12-28 4217
因此，队列判空的条件是front = = rear，
数据结构——队列 求队列长度 C语言
03-16
输入若干个整数, 以0结束, 利用入队的操作生成一个循环队列, 求该队列的长度。
数据结构实现顺序循环队列
09-16
编写一个程序，实现顺序循环队列的各种基本运算，完成如下功能 （1） 初始化队列 （2） 判断队列是否为空 （3） 依次进队元素a, b, c,d （4） 出队一个元素，输出该元素 （5） 输出队列的元素个数 （6） 依次进队列元素e，f （7） 输出队列的元素个数 （8） 输出队列序列
数据结构入门——队列的实现.rar
04-02
队列是一种先进先出的数据结构：即插入在表的一端（队尾）进行，删除在表的另一端（队头）进行 与线性表相似，队列也有顺序储存和链式储存两种储存方法；实现方法和代码在此文档中，详细说明见本人博客
图解数据结构（使用Python）——队列
12-20
队列是一种抽象数据类型，具有先进先出的原则。 特性： 与堆栈（只有一个top指针）不同的是，队列有head和rear两个指针，分别指向队列的头和尾 有加入和删除两种基本操作，且在rear指针处加入元素，在head指针处删除...
数据结构课设——队列程序.pdf
10-06
数据结构课设——队列程序.pdf
数据结构：Queue队列
辰多代码的博客
09-11 148
队列：数据结构线性表的一种，它与栈不同，栈是先进后出，而队列是先进先出，在队尾入列，在队头出列。队头（head）：队列中出队列的一端队尾（tail）：队列中插入队列的一端​。
数据结构之循环队列队空队满判断
weixin_65244731的博客
10-21 2249
简单易懂----数据结构之循环队列队空队满判断
java数据结构02（队列）
weixin_55139299的博客
05-30 711
java实现队列
循环队列：判断队列空和满的3种方法
热门推荐
xxxxxxyao的博客
02-14 5万+
  一.少用一个存储位置   第一种情况： 当队列为空时条件：rear == front 当队列满时条件为：rear+1 == front      上述方式对于上述图是适用的，但如果出现了有下标标识，上述判断条件就不适用了。比如下图有下标了，当队列满时，显然条件就不能判断了，就要用到另一种判断。   第二种情况： 当队列为空时条件：rear == front 当队列满时条件为：（rear+1）...
数据结构课设——航空航天订票系统
12-10
这个航空航天订票系统的数据结构包括航班信息、乘客信息、预定队列等。其中航班信息包括航班编号、起点、终点、出发时间、到达时间、机型、剩余座位数等；乘客信息包括姓名、身份证号、订票等级等。预定队列则是用来存储没有订到座位的乘客信息，以便后续安排。 该系统的设计思路是先通过管理员添加航班信息，然后乘客可以通过查询所有航班或者根据起点终点搜索航班来选择自己想要的航班。订票时，系统会检查该航班是否还有剩余座位，若有则订票成功，否则会推荐其他航班或者进入预定队列。退票时，系统会将该乘客的座位释放，并更新航班的剩余座位数。管理员可以添加或删除航班信息。 该系统的特点是实现了航班信息的管理、乘客订票、退票等功能，同时还考虑了预定队列的情况，能够更好地满足用户需求。不足之处可能在于界面设计和用户体验方面还有待改进。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小小修士

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

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

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

打赏作者

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

抵扣说明：

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

余额充值