【算法基础】广度优先搜索(BFS)

1 定义

广度优先搜索 (Breadth First Search)又叫层次遍历或宽度优先搜索,通常是以二叉树或图作为研究对象,先从上往下对该二叉树的每一层依次访问,在每一层中,从左往右(也可以从右往左)访问结点,访问完当前层才进入下一层,直到没有结点可以访问为止。

2 例题

【leetcode-102】给你二叉树的根节点 root ,返回其节点值的 层序遍历 。 (即逐层地,从左到右访问所有节点)。

【算法基础】广度优先搜索(BFS)_第1张图片

3 解决方法

3.1 双数组

3.1.1 大致思路

创建两个vector,分别为cur和next,其中cur含有当前访问层中的所包含的节点,next含有cur(极next的上一层)的各个节点的左右子节点,创建一个数组vals用来储存各个节点的值。遍历cur中的每个节点,将其每个节点的子节点放入next中,如果是nullptr就不放(这样的话,直到该二叉树的最后一层,将不再有子节点,也可以成为循环的符合条件),同时,将cur中的每个节点的节点值放到vals中,遍历结束后将cur替换成next就可以才是下一轮的遍历了,知道cur中不再有节点为止。

3.1.2 具体步骤

1 声明一个cur的数组,并使其初始化含有root节点;

2 以cur数组中存在节点为条件,开始外层循环;

3 声明一个数组vals用来储存cur数组个各个节点的值;

4 声明一个数组next以从左到右(或从右到左)的顺序,来储存cur的子节点;

5 开始内层循环用来将cur数组中的节点的值放入vals中,并且将cur中的各个子节点的存放到next中;

6 离开内层循环(仍在外层循环内),开始善后工作:将vals放入ans内,将cur数组用next来替换

3.1.3 代码

class Solution {
public:
    vector> levelOrder(TreeNode* root) {
        if(root == nullptr){        //考虑root不存在的极端情况
            return {};
        }
        vector> ans;        //声明最后返回的答案
        vector cur = {root};        
        while(cur.size()){
            vector vals;        
            vector next;
            for(auto node:cur){
                vals.push_back(node->val);
                if(node->left){
                    next.push_back(node->left);
                }
                if(node->right){
                    next.push_back(node->right);
                }
            }
            cur = move(next);        
            ans.emplace_back(vals);
        }
        return ans;
    }
};

3.2 单队列

3.2.1 大致思路

利用队列这个数据结构(先进先出)的特性,将root节点放入队列中去,然后将其值赋个用来储存各个节点值的vals数组中,然后将该节点的各个子节点再放入相同的队列(即自己这个节点的后面),如此循环。

3.2.2 具体步骤

1 声明答案ans,一个存放节点的队列q,并将root节点放到q中去;

2 以队列q不是空的作为循环条件,开启外层循环用来依次存放当前层的节点;

3 声明一个用来储存各节点值的数组vals;

4 以队列中仍有节点为循环条件,开启内层循环用来遍历当前层的节点;

5 内层循环中,声明一个暂时的变量用来存放队列头部的节点;

6 存放完成后弹出头节点,并将头节点的值存放入vals中;

7 检查当前节点是否有子节点,如有,将其子节点放入队列

8 跳出内层循环(仍在外层循环中),将vals存放入ans中

3.2.3 代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector> levelOrder(TreeNode* root) {
        if(root == nullptr){        //考虑root不存在的极端情况
            return {};
        }
        vector> ans;        //声明答案ans,一个存放节点的队列q,并将root节点放到q中去;
        queue q;
        q.push(root);
        while(!q.empty()){        //以队列q不是空的作为循环条件,开启外层循环用来依次存放当前层的节点;
            vector vals;        //声明一个用来储存各节点值的数组vals;
            for(int n = q.size();n--;){        //以队列中仍有节点为循环条件,开启内层循环用来遍历当前层的节点;

                auto node = q.front();        //内层循环中,声明一个暂时的变量用来存放队列头部的节点;
                q.pop();        //存放完成后弹出头节点,并将头节点的值存放入vals中;
                vals.push_back(node->val);
                if(node->left){        //检查当前节点是否有子节点,如有,将其子节点放入队列

                    q.push(node->left);
                }
                if(node->right){
                    q.push(node->right);
                }
            }
            ans.emplace_back(vals);        //跳出内层循环(仍在外层循环中),将vals存放入ans中
        }
        return ans;
    }
};

你可能感兴趣的:(算法基础,c++,bfs,算法)