广度优先搜索

广度优先搜索

1. 开幕式焰火

• 套用广度优先算法模板，需要一个队列和一个哈希表
• 先把每个元素插入队列，记录结点的颜色之后删除。
• 利用哈希表判断该结点是否之前出现过， 也就是排除颜色相同的结点。

/**
 * 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:
    int numColor(TreeNode* root) {
        queue<TreeNode*> q;
        int hash[1010];
        memset(hash, 0, sizeof(hash));
        int cnt = 0;
        q.push(root);

        while(!q.empty()) {
            TreeNode *now = q.front();
            q.pop();
            if(now) {
                if(!hash[now->val]) {
                    hash[now->val] = 1;
                    cnt++;
                }
                q.push(now->left);
                q.push(now->right);
            }
        }
        return cnt;
    }
};

2. 二叉树的层序遍历

• 也是一样的用一个队列，出队入队去遍历整个二叉树
• 用一个哈希表存储每个结点的深度，再根据不同的深度存入二维数组中并返回。

```/**
 * 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<vector<int>> levelOrder(TreeNode* root) {
        if(root == nullptr) return {};
        vector<vector<int>> ret;
        queue<TreeNode*> q;
        unordered_map<TreeNode*, int> dep;
        q.push(root);
        dep[root] = 0;
        int predep = -1;

        while(!q.empty()) {
            TreeNode* now = q.front();
            q.pop();

            if(dep[now] != predep) {
                ret.push_back({now->val});
                predep = dep[now];
            } else {
                ret.back().push_back(now->val);
            }

            if(now->left) {
                dep[now->left] = dep[now] +1;
                q.push(now->left);
            }

            if(now->right) {
                dep[now->right] = dep[now] +1;
                q.push(now->right);
            }
        }
        return ret;
    }
};