[LeetCode] 104/111. Maximum Depth of Binary Tree 二叉树的最大/最小深度

Category	Difficulty	Likes	Dislikes
algorithms	Easy (73.29%)	591	-

TagsCompanies

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

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

    3
   / 
  9  20
    /  
   15   7

返回它的最大深度 3 。

方法一：使用 102 题求二叉树的层数，层数即是最大深度。

方法二：递归地求左右子树的最大深度，取两者最大值+1。

两种方法代码如下：

/*
 * @Descripttion: 
 * @version: 
 * @Author: wangxf
 * @Date: 2020-07-07 22:59:43
 * @LastEditors: Do not edit
 * @LastEditTime: 2020-07-08 00:01:54
 */ 
/*
 * @lc app=leetcode.cn id=104 lang=cpp
 *
 * [104] 二叉树的最大深度
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
struct NodeInfo
{
    TreeNode* ptr = nullptr;
    int level = 0;
    NodeInfo(TreeNode* node_ptr,int node_level):
    ptr(node_ptr),level(node_level)
    {}
};

class Solution {
public:
    int maxDepth(TreeNode* root) 
    {
        //方法一：层次遍历，树的层树则为树的最大深度
       // return level_traverse_helper(root);
        //方法二：递归求左子树，右子树的最大深度，取两者的最大值+1
        return maxDepth_recursion(root);
    }

    int level_traverse_helper(TreeNode* root)
    {
        std::vector<vector<int>> res;
        if(!root) return 0;
        std::queue<NodeInfo> q;
        NodeInfo root_node(root,0);
        q.push(root_node);
        while(!q.empty())
        {
            NodeInfo cur_node = q.front();
            q.pop();
            int cur_level = cur_node.level;
            int cur_node_val = cur_node.ptr->val;
            if(res.size()<cur_level+1)
            {
                vector<int> tempVec;
                res.push_back(tempVec);
            }
            res[cur_level].push_back(cur_node_val);
            if(cur_node.ptr->left)
            {
               NodeInfo leftNode(cur_node.ptr->left,cur_level+1);
               q.push(leftNode);
            }
            if(cur_node.ptr->right)
            {
               NodeInfo rightNode(cur_node.ptr->right,cur_level+1);
               q.push(rightNode);
            }
        }
        int res_size = res.size();
        return res_size;
    }

    int maxDepth_recursion(TreeNode* root)
    {
        if (!root) //对空树测试用例，返回0
        {
            return 0;
        }
        if((!root->left)&&(!root->right))//leaf node
        {
            return 1;
        }
        int left_max_depth = maxDepth_recursion(root->left);
        int right_max_depth = maxDepth_recursion(root->right);
        int max_depth = max(left_max_depth,right_max_depth)+1;
        return max_depth;
    }
};
// @lc code=end

 方法二同理可以求二叉树的最小深度，代码如下：

/*
 * @Descripttion: 
 * @version: 
 * @Author: wangxf
 * @Date: 2020-07-07 23:12:22
 * @LastEditors: Do not edit
 * @LastEditTime: 2020-07-07 23:46:05
 */ 
/*
 * @lc app=leetcode.cn id=111 lang=cpp
 *
 * [111] 二叉树的最小深度
 */

// @lc code=start
/**
 * 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 minDepth(TreeNode* root)
    {
        if (!root) //对空树测试用例，返回0
        {
            return 0;
        }
        return minDepthHelper(root);
    }

    int minDepthHelper(TreeNode* root)
    {
        if (!root) //若子树为空，则只考虑另一子树的最小深度，另一子树也为空的情况是上层节点是叶子节点，下面单独考虑
        {
            return 0x7fffffff;
        }
        if((!root->left)&&(!root->right))//leaf node
        {
            return 1;
        }
        int left_min_depth = minDepthHelper(root->left);
        int right_min_depth = minDepthHelper(root->right);
        int min_depth = min(left_min_depth,right_min_depth)+1;
        return min_depth;
    }
};
// @lc code=end