104、二叉树的最大深度

题目

二叉树：二叉树的最大深度
给定一个二叉树 root ，返回其最大深度。

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

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：3
示例 2：

输入：root = [1,null,2]
输出：2

提示：

树中节点的数量在 [0, 104] 区间内。
-100 <= Node.val <= 100

递归代码

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

深度优先搜索（DFS）代码

超出内存限制

/**
 * 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:
    int maxDepth(TreeNode* root) {
        if(!root)
        {
            return 0;
        }
        int depth=0;
        stack<pair<TreeNode*,int>> s;
        s.push({root,1});
        while(!s.empty())
        {
            auto temp=s.top();
            s.pop();
            depth=max(depth,temp.second);
            if(temp.first->right)
            {
                s.push({temp.first,temp.second+1});
            }
            if(temp.first->left)
            {
                s.push({temp.first,temp.second+1});
            }
        }
        return depth;
    }
};

深度优先搜索原理图及解释

需要用到栈
①首先将结点3压栈，深度为1，与初始化的深度大小比较，然后3出栈。
②遍历结点3的右子树20入栈深度为2，左子树9入栈深度为2，栈顶元素9出栈，比较深度，找9的左右子树为空。
③栈顶元素20出栈，比较深度大小，遍历左右子树，7入栈深度为3，15入栈深度为3。
④栈顶元素15出栈，比较深度大小，遍历左右子树为空。
⑤栈顶元素7出栈，比较深度大小，最大深度为3，遍历左右子树为空。
⑥栈为空，循环结束，返回最大深度。

广度优先搜索（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:
    int maxDepth(TreeNode* root) {
        if(!root)
        {
            return 0;
        }
       queue<pair<TreeNode*,int>> q;
       int depth=0;
       q.push({root,1});
       while(!q.empty())
       {
            auto temp=q.front();
            q.pop();
            depth=max(depth,temp.second);
            if(temp.first->left)
            {
                q.push({temp.first,temp.second+1});
            }
            if(temp.first->right)
            {
                q.push({temp.first,temp.second+1});
            }
       }
       return depth;
    }
};

广度优先搜索原理图及解释

需要用到队列

初始化深度为0
①首先3入队，深度为1，保存好结点3，结点3出队，比较深度大小，将3的左右子树9、20入队，深度为2
②9出队，比较深度大小，左右子树为空。
③20出队，比较深度大小，左右子树入队15、7深度为3。
④15出队，比较深度大小，左右子树为空。
⑤7出队，比较深度大小，左右子树为空，最大深度为3。
⑥整个队列为空循环结束，返回最大深度。

结束

原理图借鉴哔站华南溜达虎，如有侵权联系删除。