誓要搞懂 DFS（一）

求二叉树的深度

题目

代码（DFS+BFS）

这里是要求这个二叉树的深度，我们可以使用DFS,深度优先遍历的方法来做。顾名思义，就是先一直往下搜索，直到遇到叶节点结束。这是一种大问题和小问题相同类型的问题，我么可以利用递归的方法来解决。也就是求树的深度，先求根节点的两个（如果有）子节点对应的子树的深度，这样一直递归下去，直到遇到NULL，结束。这就是这里的DFS来求解这个二叉树的深度的问题。这不完全是深度优先的思想，应该是属于后序遍历的实际使用。它这里使用每个节点的顺序是按照“左、右、根”的顺序来的。

/**
 * 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 maxDepth(TreeNode* root) {
        if(root==NULL) return 0;
        else{
            return max(maxDepth(root->left),maxDepth(root->right))+1;
        }
    }
};

这题的这种方法，主要是后序遍历的思想，也有深度优先搜索的思想。时间复杂度是O(n)，空间复杂度是O(n).
另外，还有一种方法是层序遍历，也就是类似于BFS的思想。

/**
 * 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 maxDepth(TreeNode* root) {
        if(root==NULL) return 0;
        queue<TreeNode*>a;
        int result=0;
        a.push(root);
        while(!a.empty()){
            queue<TreeNode*>temp;
            int j=a.size();
            for(int i=0;i<j;i++){
                if(a.front()->left){temp.push(a.front()->left);};
                if(a.front()->right){temp.push(a.front()->right);};
                a.pop();}
            a=temp;
            result++;                          
        }
        return result;
    }
};

这里使用的是队列来实现的BFS,通过广度优先搜索来计算二叉树的深度。这种方法也是很常见的。

检查平衡性

题目

代码(DFS+后序遍历）

/**
 * 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:
    bool isBalanced(TreeNode* root) {
        if(!root) return true;
        else if((abs(height(root->left)-height(root->right))<=1)&&
        (isBalanced(root->left))&&
        (isBalanced(root->right))) return true;
        else return false;        
    };
    int height(TreeNode* root){
        if(root==NULL){return 0;}
        else{
            return max(height(root->left),height(root->right))+1;
        }
    }
};

这个代码也是用DFS的思想来解决问题的。定义一个函数来计算每一个节点之下的子树的高度。然后用isBalanced函数来递归判断每一个节点，这里的判断方法是从上到下，可以想到，里面有很多的计算是重复的。哈哈哈哈。这个方法的时间复杂度平均是O(n logn),最坏是O(n平方)。这种方法，如果从二叉树的遍历这个方向来思考的话，其实是属于前序遍历。

下面来学习从下到上的计算方法。根据前面说到的前序遍历的思想，可以从遍历的角度来想到一种方法，可以使遍历的顺序是从下往上的。那就是后序遍历。我们知道后序遍历的“使用”顺序是“左 右 根”。但是对于二叉树，我们只能从根开始。所以这里的“使用”顺序，“使用”二字特别重要，我们的什么什么遍历，是对于各个节点的使用顺序来说的。

/**
 * 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:
    bool isBalanced(TreeNode* root) {
        return height(root)>=0;   
    };
    int height(TreeNode* root){
        if(root==NULL){return 0;}
        int leftheight=height(root->left);
        int rightheight=height(root->right);
        if(leftheight==-1||rightheight==-1||abs(leftheight-rightheight)>1){
            return -1;
        }
        else {return max(height(root->left),height(root->right))+1;}
    }
};

在这个代码里面，我们先在height()函数里面递归的调用height()函数，然后再使用当前的“根”节点。这是后序遍历的思想。然后为了和使返回值可以被isBalanced()函数使用，所以我们设置不是平衡树的返回一个小于0的值，对应false.

叶子相似的树

题目

代码

/**
 * 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:
    bool leafSimilar(TreeNode* root1, TreeNode* root2) {
        queue<int>a1;
        queue<int>a2;
        getLeaf(root1,a1);
        getLeaf(root2,a2);
        if(a1==a2){return true;}
        else {return false;}
    }
    void getLeaf(TreeNode* root, queue<int>& a){
        if(root==NULL) return;
        if(root->left==NULL&&root->right==NULL){
            a.push(root->val);
        }
        else{
            if(root->left){getLeaf(root->left,a);}
            if(root->right){getLeaf(root->right,a);}
        }
    }
};

这里的代码使用的思想是一直递归，直到遇见叶子结点。这里不涉及到要回去访问父节点的情况，相对容易一点。

二叉树的所有路径

题目

代码（DFS+BFS）

/**
 * 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<string> binaryTreePaths(TreeNode* root) {
        vector<string> paths;
        string path="";
        constructpath(root,path,paths);
        return paths;
    }
    void constructpath(TreeNode*root,string path,vector<string>& paths){
        if(root){
            path+=to_string(root->val);
            if(root->left==NULL&&root->right==NULL){
                paths.emplace_back(path);
            }
            else{
                path+="->";
                constructpath(root->left,path,paths);
                constructpath(root->right,path,paths);                
            }
        }
        else{return;}
    }
};

这是递归，这不是尾递归，因为需要保存上层函数的环境，这是利用的深度优先搜索的思想，DFS,在调用DFS的时候，有一个问题，比如说这里的constructpath()函数，里面的第二个参数path,这个参数要在递归的过程中有很多个“分身”。要分析好path参数的变化。第三个参数paths是引用，因为这个参数我们要在函数外调用，这里的函数外是指要在binaryTreePaths()函数里面调用。
还可以使用BFS，也就是广度优先的思想来做，也就是使用队列来解这道题。

/**
 * 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<string> binaryTreePaths(TreeNode* root) {
        vector<string> paths;
        if(root==NULL){
            return paths;
        }
        queue<TreeNode*> node_queue;
        queue<string> path_queue;
        node_queue.push(root);
        string path=to_string(root->val);
        path_queue.push(path);
        while(!node_queue.empty()){
            TreeNode*node1=node_queue.front();
            string path1=path_queue.front();            
            node_queue.pop();
            path_queue.pop();
            if(node1->left==NULL&&node1->right==NULL){
                paths.push_back(path1);
            }
            else{
                if(node1->left!=NULL){
                    path_queue.push(path1+"->"+to_string(node1->left->val));
                    node_queue.push(node1->left);
                }
                if(node1->right!=NULL){
                    path_queue.push(path1+"->"+to_string(node1->right->val));                
                    node_queue.push(node1->right);
                }
            }
        }
        return paths;
    }

};

这里用vector来存储所有的路径，用node_queue来存储还未“使用”的节点。用path_queue这个队列来存储当前还未遍历到叶节点时的路径。