二叉树的层序遍历——bfs和dfs起始章节

在很多问题中，我们都要对所有情况进行遍历，二叉树是其中的一项，再比如矩阵类。正好每日一题做到了，就顺便拿出来总结一下遍历。
概念性的东西我就不说了，直接说我的理解，bfs就是从此点往四周遍历，就像水波往外扩散，特点就是先近后远，适合最短距离这种的。怎么实现？队列，先进先出，离得近的先进，近的下一个进，循环。
上本题。
题目：
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
示例：
二叉树：[3,9,20,null,null,15,7],
3
/
9 20
/
15 7
返回其层次遍历结果：
[
[3],
[9,20],
[15,7]
]
思路：
层层遍历，也就是一层一层的输出，这个有点棘手的地方在于，你需要将每层输出，所以你要记录每层的个数，然后挨个输出。
思路就来了，申请一个队列，先将root推入，然后开始遍历，以队列空为结束。每次要记住该层的个数，因为队列中会持续进入，所以要记住每层的个数。

/**
 * 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;
        queue<TreeNode*> q1;
        q1.push(root);
        while(!q1.empty())
        {
            int size=q1.size();
            vector<int> vec;
            while(size--)//关键是这一步，要记住你这层输出几个
            {
                TreeNode* f=q1.front();
                q1.pop();
                if(f->left)
                    q1.push(f->left);
                if(f->right)
                    q1.push(f->right);
                vec.push_back(f->val);
            }
            res.push_back(vec);
        }
        return res;
    }
};

我尝试着用两个队列来实现不用记住层中点的个数，虽然代码庞大了些许，但毕竟实现了。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root==nullptr)
            return res;
        queue<TreeNode*> q1,q2;//两个队列互相存子树
        q1.push(root);
        while(!q1.empty()||!q2.empty())
        {
            vector<int> vec1;
            while(!q1.empty())//循环到空，将该层的节点推入另一队列
            {
                TreeNode* top=q1.front();
                q1.pop();
                vec1.push_back(top->val);//将该层的结果输出
                if(top->left)
                    q2.push(top->left);
                if(top->right)
                    q2.push(top->right);
            }
            if(!vec1.empty())//有元素才输出
            {
                res.push_back(vec1);
            }
            vec1.clear();//清理
            while(!q2.empty())
            {
                TreeNode* top=q2.front();
                q2.pop();
                vec1.push_back(top->val);
                if(top->left)
                    q1.push(top->left);
                if(top->right)
                    q1.push(top->right);
            }
            if(!vec1.empty())
            {
                res.push_back(vec1);
            }
            vec1.clear();
        }
        return res;
    }
};

dfs就简单许多了，一直往下递归，递归到最后。有一个需要注意的点是我们是从左往右的，所以我们每次都先左递归，然后往右。重点就是要记住自己在哪一层，下面参数里的level。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        dfs(res,root,0);
        return res;
    }
    void dfs(vector<vector<int>>& res,TreeNode* root,int level)
    {
        if(!root)
            return;
        if(level>=res.size())
        {
            res.push_back(vector<int>());//每有一层就开辟一层的输出空间
        }
        res[level].push_back(root->val);//此处的level是关键，每次都递归到此就输出此层
        dfs(res,root->left,level+1);
        dfs(res,root->right,level+1);
    }
};

说到底，还是遍历的问题，扩散遍历和纵深遍历，有时候会有剪枝问题，也就是不符合条件的扩散可以直接掐掉此路，递归就是回溯回上一步。这些之前的博客里也都有提到过。
知识都是发散和总结出来的，加油。