javaScript数据结构——队列

最新推荐文章于 2022-10-15 19:34:37 发布
最新推荐文章于 2022-10-15 19:34:37 发布
阅读量95 收藏
点赞数
分类专栏： js 文章标签： javaScript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuefujuan_1992/article/details/89041992
版权
队列：

队列是遵循先进先出（FIFO，first in first out）原则的有序集合，队列在尾部添加元素，在顶部移除元素，最新添加的元素必须排在队列的尾部。

比如：排队，打印机的打印队列
在这里插入图片描述

队列的实现：
<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>队列</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">

</head>

<body>
    <script>
        //声明类
        function Queue(){
            let items = [];
            this.enqueue = function(ele){
                items.push(ele);
            }
            this.dequeue = function(ele){
                items.shift(ele);
            }
            this.front = function(){
                return items[0];
            }
            this.isEmpty = function(){
                return items.length == 0;
            }
            this.size = function(){
                return items.length;
            }
            this.print = function(){
                return console.log(items.toString())
            }
        }
        let queue = new Queue();
        console.log(queue.isEmpty())
        queue.enqueue("hello")
        queue.print()
        console.log(queue.size())
        console.log(queue.isEmpty())
        queue.dequeue()
        queue.print()


        //ES6实现Queue类
        //用WeakMap来保存私有属性items
        // let Queue = (function () {
        //     const items = new WeakMap();
        //     class Queue {
        //         constructor() {
        //             items.set(this, [])
        //         }
        //         enqueue(ele) {
        //             let s = items.get(this);
        //             s.push(ele);
        //         }
        //         dequeue() {
        //             let s = items.get(this);
        //             let r = s.shift();
        //             return s;
        //         }
        //         front() {
        //             let s = items.get(this);
        //             return s[0];
        //         }
        //         isEmpty() {
        //             let s = items.get(this);
        //             return s.length == 0;
        //         }
        //         size() {
        //             let s = items.get(this);
        //             return s.length;
        //         }
        //         print() {
        //             let s = items.get(this);
        //             console.log(s.toString())
        //         }
        //     }
        //     return Queue;
        // })()

        // let queue = new Queue();
        // console.log(queue)



        // 最小优先队列
        // function PriorityQueue() {
        //     let items = [];
        //     function QueueElement(element, priority) {
        //         this.element = element;
        //         this.priority = priority;
        //     }
        //     this.enqueue = function (element, priority) {
        //         let queueElement = new QueueElement(element, priority);
        //         let added = false;
        //         for (let i = 0; i < items.length; i++) {
        //             if (queueElement.priority < items[i].priority) {
        //                 items.splice(i, 0, queueElement);
        //                 added = true;
        //                 break;
        //             }
        //         }
        //         if (!added) {
        //             items.push(queueElement);
        //         }
        //     }
        //     this.dequeue = function () {
        //         let s = items.shift();
        //         return s;
        //     }
        //     this.isEmpty = function () {
        //         return items.length == 0;
        //     }
        //     this.size = function () {
        //         return items.length;
        //     }
        //     this.front = function () {
        //         return items[0];
        //     }
        //     this.print = function () {
        //         for (let i = 0; i < items.length; i++) {
        //             console.log(`${items[i].element}-${items[i].priority}`)
        //         }
        //     }
        // }

        // let priorityQueue = new PriorityQueue();
        // priorityQueue.enqueue("John", 2);
        // priorityQueue.print()
        // priorityQueue.enqueue("Willian", 1);
        // priorityQueue.print()
        // priorityQueue.enqueue("C", 2);
        // priorityQueue.print()
        // console.log(priorityQueue.size())
        // console.log(priorityQueue.isEmpty())
        // console.log(priorityQueue.front())
        // console.log(priorityQueue.dequeue())

    </script>
</body>

</html>
nancyyue_199
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript数据结构——队列数据结构
Jyao_In的博客
04-20 608
1. 队列 队列是遵从先进先出（FIFO，也称为先来先服务）原则的一组有序的项。队列在尾部添加新元素，并从顶部移除元素。最新添加的元素必须排在队列的末尾。最常见的例子就是排队。 下面是用对象存储队列中数据结构的类。需要声明一些队列可用的方法。 enqueue(element(s)): 向队列尾部添加一个（或多个）新的项。 dequeue(): 移除队列的第一项，并返回被移除的元素。 peek(): 返回队列中第一个元素。队列不作任何变动。 isEmpty(): 如果队列中不包含任何元素，返回tr
JavaScript数据结构——队列（Queue）
瓜冬瓜的博客
06-21 931
概念和结构 队列是一种先进先出（FIFO）的数据结构。 队列的第一个元素所在位置称为队头，最后一个元素所在位置称为队尾。 不包含任何元素的队列称为空队列。 队列的操作 队列有五种常用操作，分别为 入队 enqueue（element） 出队 dequeue（） 检查队头元素 front（） 检查队列是否为空 isEmpty（） 获取队列的长度 size（） JS实现 JS里面的队列结构也...
JavaScript数据结构——队列
qq_52748669的博客
08-24 417
JavaScript数据结构——队列
javascript数据结构——队列
qq_47218954的博客
04-22 1404
javascript 数据结构 队列
JavaScript 数据结构——队列
火星基地
03-13 180
概念 队列是一个线性结构，特点是先进先出。 入队push()： 出队shift()： 实现 class Queue { constructor() { this.queue = [] } push(item) { // 入队 this.queue.push(item) } shift() { // 出队 return this.queue.shift() } getH
JAVASCRIPT数据结构 —— 队列Queue
weixin_48920282的博客
12-29 454
3.1：Queue概念 - 队列是一种 列表，不同的是队列只能在队尾插入元素，在队首删除元素。 - 队列是一种先进先出的数据结构。( First-In-First-Out ) - 队列主要的两个操作：队尾插入元素，在队首删除元素。 3.2：Queue的方法 enqueue(element) 向队列尾部添加元素 dequeue() 移除队列的第一项，并返回被移除的元素 peek() 返回队列中第一个元素——最先被添加的 isEmpty() 判断队列是否为空，返回boolean size() 返
JavaScript数据结构——优先队列
403 Forbidden
03-04 263
JavaScript中的优先队列 普通队列在插入元素时只会放到后端，导致只能等待前面的数据处理完毕后才可以被处理 而优先队列在插入元素时会考虑该数据的优先级，根据优先级确定插入顺序；其余方法和队列一致 程序中的优先队列 每个线程处理的任务重要性不同，可以通过设置优先级大小，来决定改线程在队列中被处理的顺序 优先队列实现 JavaScript 代码实现队列结构 // 封装优先级队列 function PriorityQueue() { var items = [] // 封装一个新的构造函数, 用于
JavaScript数据结构——图
读心悦
05-29 629
文章目录图的术语图的三种表示创建Graph类 图的术语 图是网络结构的抽模型。是一组由边连接的节点，在二元关系中是使用图结构来表示的。 相邻顶点：通过一条边连接在一起的顶点 图的三种表示 邻接矩阵，每一个节点都和一个整数关联，该整数作为节点的索引。 邻接表，由图中每一个顶点的相邻顶点列表组成 关联矩阵，矩阵的行表示顶点，列表示边 创建Graph类 持续更新中 ...
JavaScript数据结构——队列的实现
tmchongye的专栏
03-18 2625
前面楼主简单介绍了JavaScript数据结构栈的实现，http://www.cnblogs.com/qq503665965/p/6537894.html，本次将介绍队列的实现。   　　队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为
Javascript常见数据结构二——队列
weixin_52624209的博客
07-14 301
Javascript常见数据结构二——队列,通过本节对队列的学习 ，您将收获js队列的基本概念、自定义队列、通过队列实现jq动画队列、双向队列、优先级队列、击鼓传花效果！
基于JavaScript的数据结构队列动画实现示例解析
10-14
本文主要讲解了如何使用JavaScript实现一个数据结构——队列，并通过动画形式进行可视化演示。队列是一种遵循先进先出（FIFO）原则的数据结构，它允许在队列尾部插入元素（入队），在队列头部删除元素（出队）。这种...
数据结构——队列 （队列结构、队列实现、优先级队列、队列面试题）
qq_52301431的博客
08-22 426
普通的队列插入一个元素, 数据会被放在后端. 并且需要前面所有的元素都处理完成后才会处理前面的数据.- 比如每个线程处理的任务重要性不同, 我们可以通过优先级的大小, 来决定该线程在队列中被处理的次序.- 比较完成后, 可以得出这个元素正确的队列中的位置. 其他处理方式, 和队列的处理方式一样.一旦优先级, 大于某个元素, 就将该元素插入到元素这个元素的位置. 其他元素会依次向后移动.- `dequeue()`：移除队列的第一（即排在队列最前面的）项，并返回被移除的元素。
JavaScript数据结构——链表
郊眠寺
05-30 1246
前言 嘿，掘友们！今天我们来了解并实现数据结构 —— 链表。 本文主要内容 单向链表 双向链表 循环链表 链表 要存储多个元素，数组可能是最常用的数据结构。但是这种数据结构有一个缺点，数组的大小是固定的，从数组的起点或中间插入或移除的成本很高，因为需要移动元素。 链表存储有序的元素集合，不同于数组的是，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（指针或链接）组成。下图是一个链表的结构。 相比数组，链表的一个好处在于，添加或移除元素的时候不需要移动其
【JS数据结构】线性结构——队列
最新发布
早睡早起长头发的博客
10-15 968
一. 队列结构 1.队列(Queue) 2.生活中类似的队列结构 3.队列的图解 4.队列在程序中的应用 二. 队列实现 1.队列的创建 1.1 创建自己的类, 来表示一个队列 1.2 代码解析 2.队列的操作 2.1 方式一 2.2 方式二——建议使用 三. 优先级队列 1.优先级队列的特点 2.优先级队列应用 3.优先级队列的实现 四. 队列面试题 1.击鼓传花
js中的按位运算：与&、或|、异或^、按位取反、左移、右移
yuefujuan_1992的博客
04-22 3625
与（&）运算： eg: x&y 先将x、y转为二进制数，然后对x 、y的每一位数值进行比较，只有数值都为1时才取1，否则为0. 14&15
解决异步的方式
yuefujuan_1992的博客
04-06 3355
js是单线程的，一次只能完成一个任务，如果有多个任务，就需要排队，如果有一个任务耗时很长，那么后边任务就需要等待。为了解决这个问题，js将任务的执行分成两种模式：同步和异步 同步：会阻塞后面程序的运行 console.log(100) alert(200) //只有点击了确认按钮，后面的程序才会接着执行 console.log(300); 异步：不会阻塞后面程序的运行 console.log...
webpack3升级到webpack4问题汇总
yuefujuan_1992的博客
06-29 651
说明：项目是使用creact-react-app脚手架起的，记录一下升级过程中碰到问题 问题1 Plugin could not be registered at 'html-webpack-plugin-before-html-processing'. Hook was not found. 解决方案： 升级webpack webpack-cli html-webpack-plugin yarn add webpack@4.16.5 yarn add webpack-cli@3.1.0 yarn ad
javaScript数据结构——集合
yuefujuan_1992的博客
04-07 450
集合是由一组无序且唯一（即不能重复）的项组成的。 集合间的操作：并集、交集、差集 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-s...
javaScript数据结构——字典
yuefujuan_1992的博客
04-05 378
字典： 字典是一些节点的集合，每个节点包含一个key和value。 字典就是一种以【键-值】对儿的形式存储数据的数据结构。 javaScript中的Object类就是以字典的形式设计的。 字典的实现： <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> &lt...
JavaScript从零实现队列数据结构
在JavaScript中，队列是一种先进先出（FIFO，First In First Out）的数据结构，它遵循特定的规则，即新元素添加到队列的尾部，而移除元素则从队列的头部开始。下面将详细介绍如何使用JavaScript实现队列。 ### 基于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值