代码随想录67——二叉树8——二叉树的最大深度

🌈hello，你好鸭，我是Ethan，西安电子科技大学大三在读，很高兴你能来阅读。

✔️目前博客主要更新Java系列、项目案例、计算机必学四件套等。
🏃人生之义，在于追求，不在成败，勤通大道。加油呀！

🔥个人主页：Ethan Yankang
🔥推荐：史上最强八股文 || 一分钟看完我的上千篇博客

🔥温馨提示：划到文末发现专栏彩蛋   点击这里直接传送

🔥本篇概览：数据结构与算法 || 详细讲解了使用递归（掌握精髓）和迭代法（有模版）来求树的最大深度。🌈⭕🔥

---

【计算机领域一切迷惑的源头都是基本概念的模糊，算法除外】

---

🌈序言

算法乃我长久之志也，此关必过。今日得此代码随想录之良品辅助，应按此路学之习之，而长久不可懈怠。

前一系列文章详细讲解了XX，建议先将这部分知识掌握之后再来学习本篇内容，点击查看。

---

🔥 代码随想录66——二叉树7——判断是否为对称二叉树-CSDN博客

🔥 代码随想录系列所有算法精讲一键查阅

---

🌈引出

---

题目：

104.二叉树的最大深度

力扣题目链接(opens new window)

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

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

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

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

返回它的最大深度 3 。

---

剖析题干重点：

---

🔥思路分析：

看完本篇可以一起做了如下两道题目：

• 104.二叉树的最大深度(opens new window)
• 559.n叉树的最大深度(opens new window)

#递归法

本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。

• 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始)(针对一棵树而言的)
• 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始)(针对节点而言的）

而根节点的高度就是二叉树的最大深度，所以本题中我们通过后序求的根节点高度来求的二叉树最大深度。

这一点其实是很多同学没有想清楚的，很多题解同样没有讲清楚。

我先用后序遍历（左右中）来计算树的高度。

---

1.确定递归函数的参数和返回值：

参数就是传入树的根节点，返回就返回这棵树的深度，所以返回值为int类型。

代码如下：

int getdepth(TreeNode* node)

---

2.确定终止条件：

如果为空节点的话，就返回0，表示高度为0。

代码如下：

if (node == NULL) return 0;

---

3.确定单层递归的逻辑：

先求它的左子树的深度，再求右子树的深度，最后取左右深度最大的数值 再+1 （加1是因为算上当前中间节点）就是目前节点为根节点的树的深度。

代码如下：

int leftdepth = getdepth(node->left);       // 左
int rightdepth = getdepth(node->right);     // 右
int depth = 1 + max(leftdepth, rightdepth); // 中
return depth;

完整代码： 

class Solution {
public:
    int getdepth(TreeNode* node) {
        if (node == NULL) return 0;
        int leftdepth = getdepth(node->left);       // 左
        int rightdepth = getdepth(node->right);     // 右
        int depth = 1 + max(leftdepth, rightdepth); // 中
        return depth;
    }
    int maxDepth(TreeNode* root) {
        return getdepth(root);
    }
};

---

---

#迭代法

使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。

在二叉树中，一层一层的来遍历二叉树，记录一下遍历的层数就是二叉树的深度，如图所示：

所以这道题的迭代法就是一道模板题，可以使用二叉树层序遍历的模板来解决的。

如果对层序遍历还不清楚的话，可以看这篇：二叉树：层序遍历登场！

 广度优先可以使用队列模拟，深度优先可以使用栈模拟。

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录深度
            while(size-->0){
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

那么我们可以顺便解决一下n叉树的最大深度问题。

---

🌈最终代码：

递归法：

三部曲核心之——每一层要做的动作

//递归这里面是每一层的逻辑结构
//所以递归本质上还是每一层的操作；只不过这个总之条件会落在某一层上，
//那就直接先判断是不是终止条件了。
//可能有层（叶子层）为null，那就是直接返回的0了，不算他的子节点了。

class Solution {
    /**
     * 递归法
     */
    public int maxDepth(TreeNode root) {
       if (root == null) {
            return 0;
        }
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
//正常的层，返回他的左右节点的层的高度+1;
        return Math.max(leftDepth, rightDepth) + 1;
    }
}

---

---

迭代法：

使用层序遍历

class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null)return 0;
        Deque<TreeNode> deque=new LinkedList<>();
        deque.offer(root);//首层入队列
        int depth=0; // 首层深度肯定是0,这里直接赋值就好。

        while(!deque.isEmpty()){        // 只要这里的队列是空的，那就结束循环。
            int size=deque.size();
            depth++;            // 一个Size遍历完了就进入下一层了。这里的depth也要++；

            // 遍历队列的深度,使得这颗树的左右节点都完全放入队列后面去，
            // 之后再遍历他们。这就是完全的层序遍历的思路

            while(size-->0){
                TreeNode node=deque.poll();  // 先将node获取得到，后面就直接没有了。
                if(node.left!=null)deque.offer(node.left);
                if(node.right!=null)deque.offer(node.right);

             }
        }

        return depth;
    }
}

---

今日问题：

---

🔥今日总结：

0.递归法精髓：

//递归这里面是每一层的逻辑结构
//所以递归本质上还是每一层的操作；只不过这个总之条件会落在某一层上，
//那就直接先判断是不是终止条件了。
//可能有层（叶子层）为null，那就是直接返回的0了，不算他的子节点了。

class Solution {
    /**
     * 递归法
     */
    public int maxDepth(TreeNode root) {
       if (root == null) {
            return 0;
        }
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
//正常的层，返回他的左右节点的层的高度+1;
        return Math.max(leftDepth, rightDepth) + 1;
    }
}

1.背住层序遍历的核心代码：

class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null)return 0;
        Deque<TreeNode> deque=new LinkedList<>();
        deque.offer(root);//首层入队列
        int depth=0; // 首层深度肯定是0,这里直接赋值就好。

        while(!deque.isEmpty()){        // 只要这里的队列是空的，那就结束循环。
            int size=deque.size();
            depth++;            // 一个Size遍历完了就进入下一层了。这里的depth也要++；

            // 遍历队列的深度,使得这颗树的左右节点都完全放入队列后面去，
            // 之后再遍历他们。这就是完全的层序遍历的思路

            while(size-->0){
                TreeNode node=deque.poll();  // 先将node获取得到，后面就直接没有了。
                if(node.left!=null)deque.offer(node.left);
                if(node.right!=null)deque.offer(node.right);

             }
        }

        return depth;
    }
}

---

2.java中的队列函数

注意java中的队列进出的函数：

Deque<TreeNode> deque = new LinkedList<>();

这行代码创建了一个Deque（接口）（双端队列）对象deque，并使用LinkedList来实现这个双端队列。

---

出队列：

deque.poll()

---

进队列：

deque.offer()

---

---

🌈3.java集合框架的四大接口与实现（重要！！！！！）

在 Java 集合框架中，类似的接口还有：

1. List：有序、可重复的集合接口，常见实现类有 ArrayList、LinkedList 等。
2. Set：不允许重复元素的集合接口，如 HashSet、TreeSet 等。
3. Queue：队列接口，常见实现类有 LinkedList（也可作为 Deque 实现）、PriorityQueue 等。
4. Map：键值对存储的集合接口，例如 HashMap、TreeMap 等。

这些接口定义了不同类型集合的基本操作和行为规范，方便开发者根据具体需求选择合适的实现类来使用。

---

---

📣非常感谢你阅读到这里，如果这篇文章对你有帮助，希望能留下你的点赞👍 关注❤收藏✅ 评论💬，大佬三连必回哦！thanks！！！
📚愿大家都能学有所得，功不唐捐！

👇下面是专栏彩蛋系列，你会喜欢的！（为了避免影响算法的简洁与优美，这里直接将之前的几十个专栏简化为3个部分，不过你点击开后发现惊喜。）👇

---

💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖

热门专栏

🌈🌈专栏彩蛋系列

🌈🌈史上最全八股文，欢迎收藏

🌈🌈一篇文章了解我的上千篇博客

💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖💖

---