广度优先搜索BFS

广度优先搜索

广度优先搜索是对图中的边进行系统性的探索来发现可以从源节点s到达的所有节点。该算法能够计算从源节点s到每个可达到的节点的距离（最少的边数），同时生成一棵"广度优先搜索树"，该树以源节点s为根节点，包含所有可以从s到达的节点，对于每个从源节点s可以到达的节点v,在广度优先搜索树里从节点s到节点v的简单路径所对应的的就是图中从节点s到节点v的最短路径，即包含最少边数的路径。

其核心思想就是用一个FIFO的队列维护遍历的节点，然后从队列中去取出节点依次往深层次中遍历。

示例

从上到下打印二叉树

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
剑指 Offer 32 - I. 从上到下打印二叉树

vector<int> levelOrder(TreeNode* root) 
{
	std::vector<int> res;
	if(!root)
	{
	    return res;
	}
	
	std::queue<TreeNode *> q;
	q.push(root);
	while(q.size() > 0)
	{
	    auto tmp = q.front();
	    q.pop();
	    if(tmp)
	    {
	        res.push_back(tmp->val);
	        if(tmp->left)
	        {
	            q.push(tmp->left);
	        }
	        
	        if(tmp->right)
	        {
	            q.push(tmp->right);
	        }
	    }
	}
	return res;
}

剑指 Offer 32 - II. 从上到下打印二叉树 II

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root == nullptr)
        {
            return res;
        }
        std::queue<TreeNode *>  q_node;
        q_node.push(root);
        while(!q_node.empty())
        {
            vector<int> v;
            auto len = q_node.size();
            for(int i = 0; i < len; ++i)
            {
                auto tmp = q_node.front();
                q_node.pop();

                v.push_back(tmp->val);
                if(tmp->left)
                {
                    q_node.push(tmp->left);
                }
                
                if(tmp->right)
                {
                    q_node.push(tmp->right);
                }
            }
            res.push_back(std::move(v));
        }
        return res;
    }
};

剑指 Offer 32 - III. 从上到下打印二叉树 III

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root == nullptr)
        {
            return res;
        }
        std::queue<TreeNode *>  q_node;
        q_node.push(root);
        while(!q_node.empty())
        {
            vector<int> v;
            auto len = q_node.size();
            for(int i = 0; i < len; ++i)
            {
                auto tmp = q_node.front();
                q_node.pop();
                // 奇偶层入队顺序分离
                if(res.size() % 2 == 0)
                {
                    v.push_back(tmp->val);
                }
                else
                {
                    v.insert(v.begin(), tmp->val);
                }
                if(tmp->left)
                {
                    q_node.push(tmp->left);
                }
                
                if(tmp->right)
                {
                    q_node.push(tmp->right);
                }
            }
            res.push_back(std::move(v));
        }
        return res;
    }
};