Leetcode算法题：树的最大深度（回溯、动规、BFS）

1、输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

例如：

给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

提示：

    节点总数 <= 10000

A. 回溯方法

思路：

遍历每一条路径的时候，每次进入一个子节点，深度+1；

从子节点返回父节点切换路径，深度-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 maxDepth(TreeNode* root) {
        int count = 0;
        dfs(root,count);
        return max_depth_;

    }
    void dfs(TreeNode* root, int& count){
        if(root==nullptr) {
            max_depth_ = max_depth_>count?max_depth_:count;
            return;
        }
        count++;        
        dfs(root->left,count);
        dfs(root->right,count);
        count--;
        return;
    }
    int max_depth_ = 0;
};

B. 动规方法

思路：

每一棵树的深度都一定为max(左子树深度，右子树深度)+1

代码：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};

C. BFS方法

思路：

按层遍历，遍历第n层的时候，把所有n层节点的子节点保存在一个队列里，只要子节点队列不为空，树的深度即n+1

代码：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        vector<TreeNode*> queue;
        queue.push_back(root);
        int max_depth = 0;
        while(!queue.empty()) {
            vector<TreeNode*> tmp;
            for(TreeNode* node : queue) {
                if(node->left != nullptr) tmp.push_back(node->left);
                if(node->right != nullptr) tmp.push_back(node->right);
            }
            queue= tmp;
            max_depth ++;
        }
        return max_depth ;
    }
};