leetcode：104. 二叉树的最大深度

题目来源

面试题55 - I. 二叉树的深度
104. 二叉树的最大深度

题目描述

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:
    int maxDepth(TreeNode* root) {

    }
};

题目解析

递归套路

每个root需要向它的子树要：

• 你的最大深度是多少

然后根据上面收集到的信息求出自己的最大深度：

• 此树的深度 等于 左子树的深度 与 右子树的深度 中的 最大值 +1。

class Solution {
    struct Info{
        int depth;
        Info(int depth) : depth(depth) {}
    };
    
    std::shared_ptr<Info> process(TreeNode* root){
        if(root == nullptr){
            return std::make_shared<Info>(0);
        }
        
        auto left = process(root->left);
        auto right = process(root->right);
        int depth = std::max(left->depth, right->depth) + 1;
        return std::make_shared<Info>(depth);
    }
public:
    int maxDepth(TreeNode* root) {
        return process(root)->depth;
    }
};

后续遍历

此树的深度 等于 左子树的深度 与 右子树的深度 中的 最大值 +1。

// 回溯算法思路
class Solution {
    int depth = 0;
    int res = 0;
    
    void traverse(TreeNode *node){
        if(node == NULL){
            return;
        }
        
        depth++;
        res = std::max(res, depth);
        traverse(node->left);
        traverse(node->right);
        depth--;
    }
    
public:
    // 态规划思路
    int maxDepth(TreeNode* root) {
        traverse(root);
        return res;
    }
};

class Solution {
public:
    // 动态规划思路 
     // 定义：输入一个节点，返回以该节点为根的二叉树的最大深度
    int maxDepth(TreeNode* root) {
        if(root == NULL){
            return 0;
        }
        
        int leftMax = maxDepth(root->left);
        int rightMax = maxDepth(root->right);

        return max(leftMax, rightMax) + 1;
    }
};

层次遍历

    int maxDepth(TreeNode* root) {
        if(root == NULL){
            return 0;
        }

        std::queue<TreeNode *> queue;
        queue.push(root);
        int res = 0;
        while (!queue.empty()){
            int size = queue.size();
            while (size){
                TreeNode *node = queue.front();
                queue.pop();
                if(node->left){
                    queue.push(node->left);
                }
                if(node->right){
                    queue.push(node->right);
                }
                size--;
            }
            res++;
        }

        return res;
    }

    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }

        LinkedList<TreeNode> queue = new LinkedList<>(), tmp;
        queue.offer(root);
        int ans = 0;
        while (!queue.isEmpty()){
            tmp = new LinkedList<>();
            for (TreeNode node: queue) {
                if (node.left != null){
                    tmp.offer(node.left);
                }
                if (node.right != null){
                    tmp.offer(node.right);
                }
            }
            queue = tmp;
            ans++;
        }

        return ans;
    }