leetcode刷题总结之BFS算法

leetcode刷题总结之BFS算法

1、leetcode102：二叉树的层序遍历
2、leetcode103：二叉树的锯齿形层序遍历
3、leetcode104：二叉树的最大深度

#广度优先搜索BFS使用队列（queue）来实现，整个过程也可以看做一个倒立的树形：
1、把根节点放到队列的末尾。
2、每次从队列的头部取出一个元素，查看这个元素所有的下一级元素，把它们放到队列的末尾。并把这个元素记为它下一级元素的前驱。
3、找到所要找的元素时结束程序。
4、如果遍历整个树还没有找到，结束程序。

leetcode102：二叉树的层序遍历：

//leetcode102：二叉树的层序遍历
/**
 * 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>> v;
         level(root, 0, v);
         return v;

     }
     void level(TreeNode* node, int depth, vector<vector<int>> &v)
     {
        if(!node) return;
        if(depth >= v.size()) v.push_back(vector<int> {});
        v[depth].push_back(node->val);
        level(node->left, depth+1, v);
        level(node->right, depth+1, v);
    }

    //方法二：利用BFS算法
    vector<vector<int>> levelOrder(TreeNode* root) 
    {
        vector<vector<int>> v;
        if(!root) return v;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty())
        {
            int len = que.size();
            vector<int> vet;
            for(int i = 0; i < len; i++)
            {
                TreeNode* node = que.front();
                que.pop();
                vet.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            v.push_back(vet);
        }
        return v;
    }
};

leetcode103：二叉树的锯齿形层序遍历：

//leetcode103：二叉树的锯齿形层序遍历
vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> v;
        if(!root) return v;
        queue<TreeNode*> que;
        que.push(root);
        int temp = 0;
        while(!que.empty())
        {
            int len = que.size();
            vector<int> vet;
            for(int i = 0; i < len; i++)
            {
                TreeNode* node = que.front();
                que.pop();
                vet.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);          
            }
            if(temp % 2 == 1)
            {
                reverse(vet.begin(), vet.end());
            }
            temp++;
            v.push_back(vet);
        }
        return v;

leetcode104：二叉树的最大深度：

//leetcode104：二叉树的最大深度
int maxDepth(TreeNode* root) {
		//方法一：递归
        // int m = 0;
        // int n = 0;
        // if(root == NULL) return 0;
        // else
        // {
        //     m = maxDepth(root->left);
        //     n = maxDepth(root->right);
        //     if(m > n)  return m+1;
        //     else return n+1; 
        // }
        //方法二：BFS
        if(!root) return 0;
        queue<TreeNode*> que;
        que.push(root);
        int temp = 0;
        while(!que.empty())
        {
            int len = que.size();
            for(int i = 0; i < len; i++)
            {
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            temp++;
        }
        return temp;
    }