队列的JS实现及广度优先搜索(BFS)的实现

队列是先进先出(FIFO)的数据结构,插入操作叫做入队,只能添加在队列的末尾;删除操作叫做出队,只能移除第一个元素。在JS中,用数组可以很简单的实现队列。

function Queue () {
    this.queue = [];
}
// 增加
Queue.prototype.enQueue = function(x) {
    this.queue.push(x);
    return true;
}
// 删除
Queue.prototype.deQueue = function() {
    if(this.isEmpty()) {
        return false;
    }
    this.queue.shift();
    return true;
}
// 获取队首元素
Queue.prototype.front = function() {
    if(this.isEmpty()) {
        return false;
    }
    this.queue[0];
}
// 是否为空
Queue.prototype.isEmpty = function() {
    return !this.queue.length
}

以上就实现了队列的数据结构,那么队列这种数据结构有什么作用呢?在广度优先搜索(BFS)中,很适合队列。那什么是BFS。在树的遍历中,有两种遍历方式,其中一种就是从根节点一层一层的往下遍历,这就是广度优先;另一种是先由根节点选一条路径直接遍历到叶子节点,这就是深度优先搜索(DFS)。队列可以用在BFS中,下面我们来实现一个广度优先搜索的例子,返回目标节点深度。

        let root = {
            key: 1,
            children: [
                {
                    key:2,
                },
                {
                    key:3,
                    children:[
                        {
                            key:4,
                        }
                    ]
                }
            ]
        } // 数据源

function bfs(root, target) {
    //利用上面创建的Queue,当然也可以直接用数组实现
    let queue = new Queue();
    let step = 0;  // 根节点到目标节点之间的深度
    queue.enQueue(root); //将根节点加入
    //遍历队列
    while(!queue.isEmpty()) {
        step += 1;
        let len = queue.length;
        // 分层遍历队列,没有目标元素则删除该层元素,继续遍历下一层
        for(let i =0; i<len; i++) {
            let cur = queue.front()  // 获取队首元素
            if(target === cur.key) return step; //如果是目标元素,返回
            // 如果不是,将下一层节点加入到队列
            if(cur.children && cur.children.length) {
                cur.children.map(item => {
                    queue.enQueue(item)
                })
            }
            queue.deQueue()  //然后将遍历过的节点删除,
        }
    }
}

bfs(root,4)

这样我们就完成了BFS的实现思路,大家可已参照该思路在具体的业务中灵活运用BFS。

原文地址:

队列是先进先出(FIFO)的数据结构,插入操作叫做入队,只能添加在队列的末尾;删除操作叫做出队,只能移除第一个元素。在JS中,用数组可以很简单的实现队列。

function Queue () {
    this.queue = [];
}
// 增加
Queue.prototype.enQueue = function(x) {
    this.queue.push(x);
    return true;
}
// 删除
Queue.prototype.deQueue = function() {
    if(this.isEmpty()) {
        return false;
    }
    this.queue.shift();
    return true;
}
// 获取队首元素
Queue.prototype.front = function() {
    if(this.isEmpty()) {
        return false;
    }
    this.queue[0];
}
// 是否为空
Queue.prototype.isEmpty = function() {
    return !this.queue.length
}

以上就实现了队列的数据结构,那么队列这种数据结构有什么作用呢?在广度优先搜索(BFS)中,很适合队列。那什么是BFS。在树的遍历中,有两种遍历方式,其中一种就是从根节点一层一层的往下遍历,这就是广度优先;另一种是先由根节点选一条路径直接遍历到叶子节点,这就是深度优先搜索(DFS)。队列可以用在BFS中,下面我们来实现一个广度优先搜索的例子,返回目标节点深度。

        let root = {
            key: 1,
            children: [
                {
                    key:2,
                },
                {
                    key:3,
                    children:[
                        {
                            key:4,
                        }
                    ]
                }
            ]
        } // 数据源

function bfs(root, target) {
    //利用上面创建的Queue,当然也可以直接用数组实现
    let queue = new Queue();
    let step = 0;  // 根节点到目标节点之间的深度
    queue.enQueue(root); //将根节点加入
    //遍历队列
    while(!queue.isEmpty()) {
        step += 1;
        let len = queue.length;
        // 分层遍历队列,没有目标元素则删除该层元素,继续遍历下一层
        for(let i =0; i<len; i++) {
            let cur = queue.front()  // 获取队首元素
            if(target === cur.key) return step; //如果是目标元素,返回
            // 如果不是,将下一层节点加入到队列
            if(cur.children && cur.children.length) {
                cur.children.map(item => {
                    queue.enQueue(item)
                })
            }
            queue.deQueue()  //然后将遍历过的节点删除,
        }
    }
}

bfs(root,4)

这样我们就完成了BFS的实现思路,大家可已参照该思路在具体的业务中灵活运用BFS。

原文地址:https://segmentfault.com/a/1190000016900956

原文地址:https://www.cnblogs.com/lalalagq/p/9907658.html

时间: 2024-11-09 04:35:48

队列的JS实现及广度优先搜索(BFS)的实现的相关文章

广度优先搜索(BFS)

广度优先 Description: 阿狸被困在迷宫,snoopy要去救他,snoopy可以向上.下.左.右四个方向行走,每走一步(格)就要喝掉一瓶益力多.现在给它一个迷宫地图请问:snoopy最少需要多少瓶益力多才能走出迷宫? Input: 先输入一个数t,表示测试的数据个数, 下面输入的就是t个迷宫, 每个迷宫的输入都应包含以下数据, 输入迷宫的大小 n(n<=15),表示迷宫大小为n*n. 再输入迷宫, 用大写字母“S”表示snoopy的位置, 用小写字母“E”表示阿狸被困的位置, 用“.”

【算法导论】--C++实现广度优先搜索bfs

一.题目 根据上次随机生成的100个顶点的无向图和有向图,对其进行广度优先搜索. 二.理解广度优先搜索 广度优先搜索可以将其想象成水滴落入水面溅起了的一圈一圈的涟漪,是由一个起始点开始一圈一圈进行扩散搜索的. [课上老师是这样说的,大家想象一下,发现其实非常形象] 广度优先搜索总是从一个起始点出发,首先扩散这个点周围所有的邻居,然后邻居在去扩散邻居的邻居(*^-^*)...然后一直到最后将整张图都扩散完. 三.代码实现 对于第一次随机生成100个顶点的图进行了细节的修改,将每个顶点的类型改为了自

深度优先搜索DFS和广度优先搜索BFS

DFS简介 深度优先搜索,从起点开始按照某个原则一直往深处走,直到找到解,或者走不下去,走不下去则回溯到前一节点选择另一条路径走,直到找到解为止. BFS简介 广度优先搜索,从起点开始先搜索其相邻的节点,由此向外不断扩散,直到找到解为止. 举例解释 从1开始去寻找5 DFS: 原则:优先选择左手边 过程:1-2-3-4-6-4-5 BFS: 队列情况:1 2.5     5.3 5出来则找到 遍历图中所有点 DFS: 原则:优先选择左手边 过程:1-2-3-4-6-4-5 BFS: 队列情况:1

算法与数据结构基础 - 广度优先搜索(BFS)

BFS基础 广度优先搜索(Breadth First Search)用于按离始节点距离.由近到远渐次访问图的节点,可视化BFS 通常使用队列(queue)结构模拟BFS过程,关于queue见:算法与数据结构基础 - 队列(Queue) 最直观的BFS应用是图和树的遍历,其中图常用邻接表或矩阵表示,例如 LeetCode题目 690. Employee Importance: // LeetCode 690. Employee Importance/* class Employee { publi

广度优先搜索BFS

广度优先搜索可以形成一个广度优先搜索树 算法时间为O(V+E),两重循环 输入:图g,起点start(int) 需要的数据结构:队列Q.color数组(存放每个顶点的颜色) 算法过程: 1. 预处理:1)color数组的每个值都赋为white(表示没被访问过):2)队列Q为空队列 2. 处理起点: 1)color[start]=gray,gray表示顶点已被访问,但其子节点未被处理(指的是入队列):2)Q.enQueue(start) 3. 循环以下操作,直到Q为空 1)int u=Q.deQu

广度优先搜索bfs C++实现

#include<iostream>  #include<vector>  #include<map>  #include<queue>  #include<set>  using namespace std;    vector<int> bfs(map<int, vector<int> > link, int top)  {      queue<int> qe;  //队列用来记录节点的遍历顺

PAT甲级——1091 Acute Stroke (广度优先搜索BFS)

本文同步发布在CSDN:https://blog.csdn.net/weixin_44385565/article/details/94207638 1091 Acute Stroke (30 分) One important factor to identify acute stroke (急性脑卒中) is the volume of the stroke core. Given the results of image analysis in which the core regions

GraphMatrix::BFS广度优先搜索

查找某一结点的邻居: virtual int firstNbr(int i) { return nextNbr(i, n); } //首个邻接顶点 virtual int nextNbr(int i, int j) //相对于顶点j的下一邻接顶点 { while ((-1 < j) && (!exists(i, --j))); return j; } //逆向线性试探(改用邻接表可提高效率) 对于图中的所有顶点,对每一个连通区域进行BFS: template <typename

关于宽搜BFS广度优先搜索的那点事

以前一直知道深搜是一个递归栈,广搜是队列,FIFO先进先出LILO后进后出啥的.DFS是以深度作为第一关键词,即当碰到岔道口时总是先选择其中的一条岔路前进,而不管其他岔路,直到碰到死胡同时才返回岔道口并选择其他岔路.接下来将介绍的广度优先搜索(Breadth First Search, BFS)则是以广度为第一关键词,当碰到岔道口时,总是先一次访问从该岔道口能直接到达的所有节结点,然后再按这些结点被访问的顺序去依次访问它们能直接到达的所有结点,以此类推,直到所有结点都被访问为止.这就跟平静的水面