数据结构（队列实现篇）

最新推荐文章于 2022-05-17 13:03:22 发布
最新推荐文章于 2022-05-17 13:03:22 发布
阅读量139 收藏
点赞数
文章标签： 数据结构与算法 json 前端 ViewUI
原文链接：https://juejin.im/post/5cde46abe51d45109725fdae
版权

在数据结构与算法中，队列queue是一种受限的线性储存结构，特殊之处在于它只允许在表的前端front进行删除操作，而在表的后端rear进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。遵循先进先出FIFO的规则。

队列结构示意图

队列结构使用

生活中很多地方使用到队列，例如医院门诊看病就是按挂号的号数来排队就诊；公司里面的打印机是按文件发送的顺序进行打印。

在编程中，队列常用作消息发送。例如消息发送队列。待发送的消息依次入队列，待一个消息出队列发送完毕，才会进行下一个消息出队列进行发送。

实现普通队列结构的功能
  • push(element)：push是入队列操作，其中element是需要进队列的元素，返回操作成功与否布尔值。
  • shift()：shift移除队列front元素操作，返回移除的移除元素。
  • size()：获取栈中的队列元素数量，返回一个数字。
  • isEmpty()：判断队列是否为空，返回一个布尔值。
  • peek()：返回队头元素，但不移除栈顶元素。
  • bottom()：返回队尾元素。
  • clear()：清除所有队列元素，返回操作成功与否布尔值。
进队列与出队列流程

ES6 队列结构代码
    class Queue{
    	constructor(){
    		this.lists = [];
    	}
    	size(){
    		return this.lists.length;
    	}
    	isEmpty(){
    		return this.lists.length === 0;
    	}
    	peek(){
    		return this.lists[0];
    	}
    	bottom(){
    		const topIndex = this.size() -1;
    		return this.lists[topIndex];
    	}
    	push(element){
    		this.lists.push(element);
    		return true;
    	}
    	shift(){
    		return this.lists.shift();
    	}
    	clear(){
    		this.lists = [];
    		return true;
    	}
    	toString(){
    		let result = "";
    		this.lists.forEach(value=>{
    			result = result + ""+value;
    		});
    		return result;
    	}
    }
复制代码
ES5 队列结构代码

通过ES5把功能函数可以绑定在对象的实例上，也可以把功能函数加在函数的原型链上

    function Queue(){
    	this.lists = [];
    }
    Queue.prototype.push = function(element){
    	this.lists.push(element);
    	return true;
    }
    Queue.prototype.shift = function(){
    	return this.lists.shift();
    }
    Queue.prototype.clear = function(){
    	this.lists = [];
    	return true;
    }
    // 返回队头元素
    Queue.prototype.peek = function(){
    	return this.lists[0];
    }
    Queue.prototype.size = function(){
    	return this.lists.length;
    }
    Queue.prototype.isEmpty = function(){
    	return this.lists.length === 0;
    }
    Queue.prototype.bottom = function(){
    	var topIndex = this.size() -1;
    	return this.lists[topIndex];
    }
    Queue.prototype.toString = function(){
    	var result = "";
    	for(var i=0;i<this.lists.length;i++){
    		result = result + '' +this.lists[i];
    	}
    	return result;
    }
复制代码
实现优先队列结构的功能

上面实现的是普通队列情况，在日常生活中总遇到需要紧急处理的情况，例如银行VIP客户，急诊室危急病人，紧急文件。这时候需要优先处理这种情况。

优先队列和普通队列的不同主要在优先队列的每一个元素都具有一个权值，代表该元素的优先权大小。还有就是根据权值大小插入队列之中。

ES6 最大优先队列结构代码
    class Node {
        constructor(element, prority) {
            this.element = element;
            this.prority = prority;
        }
    }
    class Queue {
        constructor() {
            this.lists = [];
        }
        size() {
            return this.lists.length;
        }
        isEmpty() {
            return this.lists.length === 0;
        }
        peek() {
            return this.list[0];
        }
        bottom() {
            const topIndex = this.size() - 1;
            return this.lists[topIndex];
        }
        //插入队列
        append(node) {
            //当队列为空时
            if (!this.lists.length) {
                this.lists.push(node);
                return true;
            } else {
               for(let i=0;i<this.lists.length;i++){
                   if(this.lists[i]["prority"] < node.prority){
                       this.lists.splice(i,0,node);
                       return true;
                   }
               }
               this.lists.push(node);
            }
        }
        shift() {
            return this.lists.shift();
        }
        clear() {
            this.lists = [];
            return true;
        }
        toString() {
            let result = "";
            this.lists.forEach(value => {
                result = result + "" + value;
            });
            return result;
        }
    }
    const q = new Queue();
    q.append(new Node(1, 1));
    q.append(new Node(2, 2));
    q.append(new Node(5, 3));
    q.append(new Node(4, 2));
    console.log(JSON.stringify(q));
复制代码
ES5 最大优先队列结构代码

通过ES5把功能函数可以绑定在对象的实例上，也可以把功能函数加在函数的原型链上

    function Node(element,prority){
	this.element = element;
	this.prority = prority;
    }
    function Queue(){
    	this.lists = [];
    }
    Queue.prototype.append = function(node){
    	//当队列为空时
    	if(this.lists.length == 0){
    		this.lists.push(node);
    		return true;
    	}
    	
    	for(var i=0;i<this.lists.length;i++){
    		if(node.prority > this.lists[i]["prority"]){
              this.lists.splice(i,0,node);
              return true;
            }
    	}
    	this.lists.push(node);
    	
    }
    Queue.prototype.shift = function(){
    	return this.lists.shift();
    }
    Queue.prototype.clear = function(){
    	this.lists = [];
    	return true;
    }
    // 返回队头元素
    Queue.prototype.peek = function(){
    	return this.lists[0];
    }
    Queue.prototype.size = function(){
    	return this.lists.length;
    }
    Queue.prototype.isEmpty = function(){
    	return this.lists.length === 0;
    }
    Queue.prototype.bottom = function(){
    	var topIndex = this.size() -1;
    	return this.lists[topIndex];
    }
    Queue.prototype.toString = function(){
    	var result = "";
    	for(var i=0;i<this.lists.length;i++){
    		result = result + '' +this.lists[i];
    	}
    	return result;
    }
复制代码
循环队列结构图

循环队列就是把队头元素出队列后，再入队列。击鼓传花就是用到了循环队列的原理

循环队列代码

循环队列主要实现代码如下

  class SqQueue {
	constructor(length) {
		this.queue = new Array(length + 1)
		// 队头
		this.first = 0
		// 队尾
		this.last = 0
		// 当前队列大小
		this.size = 0
	}
	enQueue(item) {
		// 判断队尾 + 1 是否为队头
		// 如果是就代表需要扩容数组
		// % this.queue.length 是为了防止数组越界
		if (this.first === (this.last + 1) % this.queue.length) {
			this.resize(this.getLength() * 2 + 1)
		}
		this.queue[this.last] = item
		this.size++
		this.last = (this.last + 1) % this.queue.length
	}
	deQueue() {
		if (this.isEmpty()) {
			throw Error('Queue is empty')
		}
		let r = this.queue[this.first]
		this.queue[this.first] = null
		this.first = (this.first + 1) % this.queue.length
		this.size--
		// 判断当前队列大小是否过小
		// 为了保证不浪费空间，在队列空间等于总长度四分之一时
		// 且不为 2 时缩小总长度为当前的一半
		if (this.size === this.getLength() / 4 && this.getLength() / 2 !== 0) {
			this.resize(this.getLength() / 2)
		}
		return r
	}
	getHeader() {
		if (this.isEmpty()) {
			throw Error('Queue is empty')
		}
		return this.queue[this.first]
	}
	getLength() {
		return this.queue.length - 1
	}
	isEmpty() {
		return this.first === this.last
	}
	resize(length) {
		let q = new Array(length)
		for (let i = 0; i < length; i++) {
			q[i] = this.queue[(i + this.first) % this.queue.length]
		}
		this.queue = q
		this.first = 0
		this.last = this.size
	}
}
复制代码
终于水完这篇数据结构队列

Github地址: github.com/Harhao

weixin_34049032
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构（三）——队列及实现、循环队列实现
阿修罗道
09-17 2万+
一、队列     队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。在队列这种数据结构中，最先插入的元素将是最先被删除的元素；反之最后
数据结构队列(C语言实现)
m0_69888254的博客
08-06 919
1、队列的概念及结构 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头 ![在这里插入图片描述](https://img-blog.csdnimg.cn/0b38fa43e6f04bb59097866176150f34.png#pic_center) ## 2、队列的实现 队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用
数据结构-实现队列
Oldsong的博客
08-11 184
队列实现代码，整个代码一部分是自己写出来的，一部分采取书上的，很简单一看就懂，那个地方没看懂(你就要反思一下自己怎么学的)，哈哈哈，也可以评论，有时间我会解答，仅供参考不喜勿喷，欢迎大佬指点，点个赞作为鼓励呀，谢谢 代码如下： #include<stdio.h> #include<stdlib.h> //检测队列是否为空 typedef struct QueueRecord* Queue; typedef int ElementType; struct QueueRecord {
【数据结构】队列的实现
waywt1的博客
10-30 1352
目录 队列的概念及结构 队列的实现方式 数组队列 链式队列 链式队列的实现 初始化队列 入队列 出队列 获取队列头部元素 获取队列尾部元素 获取队列中有效元素个数 检测队列是否为空 销毁队列 实现队列的全部代码 测试用例 队列的概念及结构 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out)。 入队列：进行插入操作的一端称为队尾。 出队列：进行删除操作的一端称为队头。 队列的实
Python 实现数据结构中的的栈队列
09-19
本篇文章将详细探讨如何使用Python来实现这些数据结构。 首先，栈（Stack）是一种后进先出（LIFO, Last In First Out）的数据结构，它遵循“先进后出”的原则。在Python中，我们可以使用列表（List）来简单实现栈。...
队列实现栈_栈_数据结构_队列_
09-30
本篇将重点讨论如何利用队列来实现栈的功能，以及这两种数据结构在实际问题中的应用。 栈是一种后进先出（LIFO，Last In First Out）的数据结构，它的主要操作包括压入（push）元素到栈顶和弹出（pop）栈顶元素。在...
数据结构与算法详解——队列篇（附c++实现代码）
JMasker的博客
05-12 576
目录队列的概念队列的实现 队列的概念   队列的概念比较好理解，和我们现实中的排队比较相似，先进先出。栈和队列有点相似，栈有入栈出栈两种基本操作，队列相对应也有入队出队两种基本操作，不过栈只能从栈顶入，从栈顶出；而队列从队尾入，从队头出，所以队列也是一种操作受限的线性表。 队列的实现   和栈一样，用数组实现的队列叫顺序队列，用链表实现的队列叫链式队列。   前面说了，队列从队尾入，从队头出，因此我们需要维护队头head和队尾tail，顺序队列的入队和出队的代码大致是： template<typena
NDK 数据结构之队列与栈等的实现
08-29
本篇主要探讨的是如何在NDK环境中实现基本的数据结构，如队列、栈以及其他的集合类型。 首先，队列是一种先进先出（FIFO，First In First Out）的数据结构。在Java_com_tz_ndk_cpp_NDKCpp_callCppQueue方法中，可能...
数据结构 之 队列实现
王木木
09-17 585
与栈一样，队列也是一种特殊的线性表—-操作受限的线性表。也有两种存储方式，即线性存储和链接存储（链表）。但队列的入队操作只允许在队尾，出队只能在队头进行操作，所以最早入队的元素最先出队，因此队列又叫做先入先出表(FIFO）。因为动态创建队列的形式与栈基本相同，本文主要介绍线性队列的创建。动态创建队列可以参照栈的动态实现部分：https://blog.csdn.net/Chiang2018/arti...
数据结构——队列的实现
冯同学的博客
11-13 1247
文章目录一、什么是队列？二、队列的实现1.每个模块的功能2.功能的实现3.测试程序总结 一、什么是队列？ 队列的概念及结构：队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为对头 队列在生活中的应用也非常广泛，例如我们平时买东西付款，先排队的就先付款，后排队的就后付款（不允许插队）。又比如去医院挂号，先去挂号的有个挂号单（比如21号），后面的人去挂号
数据结构--队列的实现
qq_43712169的博客
02-17 214
队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。 队列是一种先入先出的数据结构。结构示意图大概如下 队尾进入，队头出队，只能移除第一个元素。 代码的实现 下面展示 队列代码的实现。 Class MyQueue{ //申请一个空间 privite List<Interger> data; private int...
数据结构---队列的实现
blue_jun_的博客
05-17 369
1.队列的概念及结构 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)原则。 入队列：进行插入操作的一端称为队尾。 出队列：进行删除操作的一端称为队头。 注：队列与栈可以说是互补关系，栈先进后出，队列先进先出，栈一般用数组实现，队列更习惯用链表实现。 2.队列的实现 队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较...
数据结构之队列的实现
liangjuming的博客
02-16 260
数据结构之队列的实现队列是一种先进先出（First-IN First-OUT, FIFO）的结构，实现队列一般有两种方法，第一是使用链表的形式实现，另外一种是使用数组实现。下面分别以这两种方式实现数据结构中的队列。一、 使用链表实现 队列一般就有下列几个函数： void init_queue(queue_node *queue); //初始化队列 bool in_queue(queue_no
数据结构之队列
热门推荐
Shuai.Zhang
07-17 2万+
队列简介 队列简单来说就是一种允许再一段进行插入，再另一端进行删除操作的线性表，就像排队取票一样。插入的一段我们称之为队尾，删除的一端我们称之为队首。队列具有FIFO（先进先出）的特性。队列的结构图如下所示。 队列的简单实现 使用上一篇文章的动态数组实现了队列，代码非常简单，不多讲了。 public class ArrayQueue { private Array&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;E&
数据结构--队列的实现（采用数组方式）
jaune162的专栏，最新动态请关注：https://jaune162.blog
04-09 715
队列概述 队列是一种先进先出的线性表（first in first out，简称FIFO）。它只允许在队列的一段插入数据，另一端取出数据。允许插入数据的一端叫做队尾（rear），允许删除的一段则称为队头（front）。 队列无论在实际生活中还是在开发中都是非常常见的。比如我们去银行办理业务的排号系统就是队列。消息中间件也是队列的思想。 队列ADT 下面给出队列的抽象定义，在后文中我们将以此ADT...
C语言实现数据结构之队结构
sjltt的博客
11-07 212
这个是链式队列，大家只要理解了队列的结构，就没什么问题了。我们先要定义节点， 在定义队列结构，也就是队列的首尾节点，大家直接上代码把。 #include<stdio.h> #include<malloc.h> #include<stdlib.h> #include<stdbool.h> typedef int Elementype; /...
数据结构（C语言）——循环队列的基本操作
qq_62692207的博客
03-29 2441
数据结构C语言第二版（严蔚敏），关于循环队列的入队、出队、取对头、求长度、遍历、清除等
Python实现模拟栈与队列数据结构
"这篇文档介绍了如何使用Python模拟两种基本的数据结构——栈和队列，并提供了相关的类定义和操作方法。栈是一种后进先出（LIFO）的数据结构，而队列则是先进先出（FIFO）的数据结构。" 在Python中，我们可以自定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值