LeetCode刷题笔记：二叉树的基本属性操作 | 4道题目 | 5道练习 | 二叉树的最大深度 | 最小深度 | 深度优先遍历 | 广度优先遍历 | 递归法 | 迭代法 | Java

已于 2024-06-27 08:22:01 修改
阅读量1.1k 收藏 30
点赞数 22
文章标签： leetcode 深度优先 java 广度优先 数据结构 算法 二叉树
于 2024-06-21 18:11:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48235955/article/details/139395774
版权

📢今天毛毛张分享的关于求解二叉树🎄属性的4️⃣道LeetCode算法题，每道题目都是1️⃣题多解🏅，并配上5️⃣道练习题，标签全部为简单题✨，赶快进来看看是不是真的简单吧！🛫

Alt
在这里插入图片描述

🙋大家好！我是毛毛张!
🌈个人首页： 神马都会亿点点的毛毛张

Alt

文章目录

0.前言

  • 🏵️今天毛毛张要分享的是关于二叉树的比较基础的LeetCode算法题，这几道题目的本质还是在考察大家对于二叉树的遍历方式是否熟悉，同时帮助大家巩固❇️二叉树的递归法和迭代法如何实现，并对每种方法的代码加上了详细的注释❗
  • 🌻如果还不熟悉的小伙伴可以先学习毛毛张的这篇博客👉之后再来做下面的题目：LeetCode刷题笔记：二叉树前序遍历、中序遍历、后序遍历和层序遍历 | 递归法 | 迭代法 | 统一迭代法 | 深度优先搜索 | 广度优先搜索
  • 🌷毛毛张在整理过程中，比较注重这些题之间的相关性❇️，下面的这几道题目是关于二叉树的基础操作，并且在LeetCode上面的标签都是简单题目，但是有很多细节需要注意
  • ⚠️在做下面几题之前，毛毛张想对下面的方法首先进行总结📳：
    • ✅深度优先遍历：
      • 🅰递归法：代码随想录的三步走方法论
        • 前序遍历
        • 中序遍历
        • 后序遍历
      • 🅱迭代法：深度优先搜索使用迭代需要借助栈
    • ✅广度优先搜索
      • 🅰递归法
      • 🅱迭代法：广度优先搜索使用迭代需要借助队列
  • 这个方法的总结也为大家在做一题多解提供了思路

1.226. 翻转二叉树

LeetCode难度标签：简单

1.1 题目说明

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

img

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：

img

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

示例 3：

输入：root = []
输出：[]

提示：

  • 树中节点数目范围在 [0, 100] 内
  • -100 <= Node.val <= 100

1.2 题解

  • 实现二叉树的翻转，本质只需要交换每一个结点的左右子树就实现了整棵树的翻转

  • 因此只需要对二叉树进行遍历，然后在遍历过程中对每个结点的左右子树进行交换就可以了

  • 二叉树有四种遍历方式：前序遍历、中序遍历、后序遍历以及层序遍历

  • 需要注意的是，唯独不可以的就是中序遍历，以下图为例，中序遍历首先遍历的节点的是结点4，然后遍历结点2，并翻转节点2，翻转之后，此时结果如右图，按照中序遍历的顺序，下面需要遍历右结点，此时右节点还是2，由于交换结点的时机在中间，导致结点2重复被反转，而结点7没有实现翻转。

    img

  • 说完上面的注意事项之后，下面就来看看几种比较常见的解法吧❗👇

1.2.1 前序遍历+递归法

class Solution {
    //递归法 三步走
    //1.确定形参和返回值：使用题目确定的形参的返回值
    public TreeNode invertTree(TreeNode root) {
        //2.确定终止条件
        if(root == null) return null;

        //3.确定单层递归逻辑
        //使用前序遍历，首先叫转中间节点的左右节点
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        //左
        invertTree(root.left);
        //右
        invertTree(root.right);
        //返回结果
        return root;
    }
}

1.2.2 前序遍历+迭代法

class Solution {
    public TreeNode invertTree(TreeNode root) {
        //迭代法 迭代遍历 借助栈
        //所有首先创建栈，存储中间遍历结果
        Stack<TreeNode> stack = new Stack<>();
        //新建TreeNode对象，表示当前处理的节点，并初始化为根节点
        TreeNode cur = root;
        //根节点入栈
        stack.push(cur);
        //开始进行迭代，首先判断根节点是否为空,如果不为空就进入循环
        while(cur != null && !stack.isEmpty()){
            //这里采用前序遍历的迭代法
            //中
            //弹出栈顶元素，并交换该节点的左右子树
            cur = stack.pop();
            TreeNode temp = cur.left;
            cur.left = cur.right;
            cur.right = temp;
            //左
            if(cur.left != null) stack.push(cur.left);
            if(cur.right != null) stack.push(cur.right);
        }

        //返回结果
        return root;
    }
}

1.2.3 层序遍历+迭代法

class Solution {
    public TreeNode invertTree(TreeNode root) {
        //迭代法 层序遍历 借助队列
        //所有首先创建队列，存储中间遍历结果
        Queue<TreeNode> queue = new LinkedList<>();
        //首先判断根节点，根节点不为空就入队
        if(root != null) queue.offer(root);
        //开始层序遍历迭代
        while(!queue.isEmpty()){
            //首先获取每一层的节点数量
            int size = queue.size();
            for(int i = 0;i<size;i++){
                //出队，创建临时变量接收出队的节点
                TreeNode cur = queue.poll();
                //交换该节点的左右子树
                TreeNode temp = cur.left;
                cur.left = cur.right;
                cur.right = temp;

                //交换完之后，把该节点的左右节点入队，下一层的时候会遍历
                //这一步的入队操作在交换左右子树之前都可以
                if(cur.left != null) queue.offer(cur.left);
                if(cur.right != null) queue.offer(cur.right);
            }
        }
        //返回结果
        return root;
    }
}

2.101. 对称二叉树

LeetCode难度标签：简单

2.1 题目说明

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

img

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

img

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

提示：

  • 树中节点数目在范围 [1, 1000] 内
  • -100 <= Node.val <= 100

进阶：你可以运用递归和迭代两种方法解决这个问题吗？

2.2 题解

  • 这个题目有两个关键点：一个是遍历的顺序，另一个是遍历终止的条件
  • 判断一颗二叉树是否为对称二叉树，因此我们可以对称遍历这棵二叉树，所谓的对称遍历，意味着遍历左右子树的顺序应该相反
  • 举例说明：如下图，以下面最小的两个子树为例，对于根节点左子树的最小左子树，按照前序遍历中左右的顺序为：3–>5–>6，那么对于根节点右子树的最小右子树，需要按照中右左的顺序进行遍历，才能得到相同的顺序为：3–>5–>6
    image-20240602184102445
  • 遍历的顺序这个问题说完了，我们来看以下遍历时判定的终止条件：
    • 左节点为空，右节点不为空，不对称，return false
    • 左不为空，右为空，不对称 return false
    • 左右都为空，对称，返回true
    • 如果左右结点都不为空，就需要判断两个结点的值是否相等，如果不相等，就返回false
      img
  • 下面来看看代码怎么写吧❗

2.2.1 递归法

class Solution {
    public boolean isSymmetric(TreeNode root) {
        //首先判断特殊情况
        if(root == null) return true;
        //开始递归
        return compare(root.left,root.right);
    }
    //递归法 三步走
    //1.确定形参和返回值，在这个题目需要新建函数
    public boolean compare(TreeNode left,TreeNode right){
        //2.确定终止条件
        if(left == null && right == null) return true;
        else if(left != null && right == null) return false;
        else if(left == null && right != null) return false;

        //3.确定单层递归逻辑
        //能运行到这一步，说明两个节点都不为空
        //首先需要判断两个节点的值是否相等,创建变量记录该结果
        boolean res1 = false;
        if(left.val == right.val) res1 = true;

        //然后判断left.left节点和right.right是否相等
        boolean res2 = compare(left.left,right.right);

        //接着判断left.right节点和right.left是否相等
        boolean res3 = compare(left.right,right.left);

        //如果上面三个结果的值均为true,这个节点才是对称节点
        return res1 && res2 && res3;

//上面分开写比较好理解
//其实最后可以综合再一次，这样的预判速度比上面的要快
//return left.val == right.val && compare(left.left,right.right) && compare(left.right,right.left);
    }
}

你们觉得这个代码是什么遍历呢？

2.2.2 迭代法

class Solution {
    public boolean isSymmetric(TreeNode root) {
        //迭代法 借助栈
        //首先创建栈，存储遍历的中间节点
        Stack<TreeNode> stack = new Stack<>();
        //判断根节点是否空，如果不为空，按照左右的顺序入栈
        if(root != null){
            stack.push(root.left);
            stack.push(root.right);
        }
        //开始迭代进行判断
        while(!stack.isEmpty()){
            //弹出栈顶的两个元素
            //首先弹出的顺序是右左
            TreeNode right = stack.pop();
            TreeNode left = stack.pop();
            //如果两个节点为空，说明是对称的
            if(right == null && left == null) continue;
            //如果左右一个节点不为空，或者都不为空但数值不相同，返回false
            else if(left != null && right == null) return false;
            else if(left == null && right != null) return false;
            else if(left.val != right.val) return false;
            //毛毛张在这里给大家留个问题：上面三行可以怎么合并？
            
            //判断完毕之后按照顺序入栈
            stack.push(left.left);      //左节点左孩子
            stack.push(right.right);    //右节点右孩子
            stack.push(left.right);     //左节点右孩子
            stack.push(right.left);     //右节点左孩子
        }
        //如果迭代完毕没有返回false，那表明这棵树是对称的，返回true
        return true;
    }
}

2.3 练习

  • 大家在做完上面这个题目之后，下面是LeetCode上面两道类似的题目，大家可以尝试着做一下，做完再看答案

2.3.1 100. 相同的树

LeetCode难度标签：简单

题目描述

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1：

img

输入：p = [1,2,3], q = [1,2,3]
输出：true

示例 2：

img

输入：p = [1,2], q = [1,null,2]
输出：false

示例 3：

img

输入：p = [1,2,1], q = [1,1,2]
输出：false

提示：

  • 两棵树上的节点数目都在范围 [0, 100] 内
  • -104 <= Node.val <= 104
题解
class Solution {
    //递归法 三步走
    //1.使用题目确定的形参和返回值
    public boolean isSameTree(TreeNode p, TreeNode q) {
        //2.确定终止条件
        if(p == null && q == null){
            return true;
        }else if(p == null && q != null){
            return false;
        }else if(p != null && q == null){
            return false;
        }else if(p.val != q.val){
            return false;
        }

        //3.确定单层的递归逻辑
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
}

2.3.2 572. 另一棵树的子树

LeetCode难度标签：简单，但是并不是那么简单

题目描述

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

示例 1：

img

输入：root = [3,4,5,1,2], subRoot = [4,1,2]
输出：true

示例 2：

img

输入：root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
输出：false

提示：

  • root 树上的节点数量范围是 [1, 2000]
  • subRoot 树上的节点数量范围是 [1, 1000]
  • -104 <= root.val <= 104
  • -104 <= subRoot.val <= 104
题解
class Solution {
    //递归遍历树 前序遍历
    //1.使用题目确定的形参和返回值
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        //2.确定终止条件
        if(root == null && subRoot == null){
            return true;
        }else if(root != null && subRoot == null){
            return true;
        }else if(root == null && subRoot != null){
            return false;
        }else if(isSameTree(root,subRoot)){
            return true;
        }

        //3.确定单层递归逻辑
        return isSubtree(root.left,subRoot) || isSubtree(root.right,subRoot);
    }

    //递归法 三步走
    //1.使用题目确定的形参和返回值
    public boolean isSameTree(TreeNode p, TreeNode q) {
        //2.确定终止条件
        if(p == null && q == null){
            return true;
        }else if(p == null && q != null){
            return false;
        }else if(p != null && q == null){
            return false;
        }else if(p.val != q.val){
            return false;
        }

        //3.确定单层的递归逻辑
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
}

这题在LeetCode上面的标签是简单题，但是大家在看完解答之后，如果没前面的铺垫，一上来就是这道题目是不是会感觉很难

3.104. 二叉树的最大深度

LeetCode难度标签：简单

3.1 题目说明

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

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

示例 1：

img

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

示例 2：

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

提示：

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

3.2 题解

这道题应该比较简单，大家应该先入为主的就是下面的第一种解法，下面跟着毛毛张一起看看有没有其它的解法吧❗

3.2.1 递归法

后序遍历递归：官方题解
class Solution {
    //递归法 三步骤
    //1.确定形参和返回值：使用题目确定的形参和返回值
    public int maxDepth(TreeNode root) {
        //2.确定终止条件
        if(root == null) return 0;

        //3.确定单层递归逻辑
        //左边的高度
        int leftDepth = maxDepth(root.left);
        //右边的高度
        int rightDepth = maxDepth(root.right);
        //以该节点为根节点的树的高度
        return 1+Math.max(leftDepth,rightDepth);
        //简写
        //方式1：
        //return maxDepth(root.left) > maxDepth(root.right) ? maxDepth(root.left)+1 : maxDepth(root.right) + 1;
        //方式2：
        //return 1 + Math.max(maxDepth(root.left),maxDepth(root.right));
    }
}
前序遍历递归：三种写法

毛毛张在这里介绍以下前序遍历递归的三种写法，这三种写法本质上是一样的，但是在处理特殊情况上的细节上是不一样的，代码本身没有很多要说的，ChatGPT推荐第一种方式，但是毛毛张写了另外两种写法，大家可以根据自己的喜欢来选择，同时也可以自己对一下这三种写法

写法1：代码随想录

class Solution {
    //创建结果返回值
    int result;
    //前序遍历 
    //递归法 三步走
    //1.确定形参和返回值
    public void getDepth(TreeNode cur,int depth){
        //2.确定终止条件
        //到叶子节点了
        //中
        result = depth > result ? depth : result;
        if(cur.left == null && cur.right == null) return;

        //左
        if(cur.left != null){
            getDepth(cur.left,depth + 1);
        }
        //右
        if(cur.right != null){
            getDepth(cur.right,depth + 1);
        }
    }
    public int maxDepth(TreeNode root) {
        //初始化深度变量
        result = 0;
        //判断特殊情况
        if(root == null) return 0;
        //开始递归
        getDepth(root,1);
        return result;
    }
}

写法2：毛毛张

class Solution {
    //创建结果返回值
    int result;
    //前序遍历 
    //递归法 三步走
    //1.确定形参和返回值
    public void getDepth(TreeNode cur,int depth){
        //2.确定终止条件
        //终止条件1:根节点为空
        if(cur == null) return;

        //终止条件2：到叶子节点了
        depth++;
        //中
        result = depth > result ? depth : result;
        if(cur.left == null && cur.right == null) return;

        //左
        if(cur.left != null){
            getDepth(cur.left,depth);
        }
        //右
        if(cur.right != null){
            getDepth(cur.right,depth);
        }
    }
    public int maxDepth(TreeNode root) {
        //初始化深度变量
        result = 0;
        //开始递归
        getDepth(root,0);
        return result;
    }
}

写法3：毛毛张

class Solution {
    //创建结果返回值
    int result;
    //前序遍历 
    //递归法 三步走
    //1.确定形参和返回值
    public void getDepth(TreeNode cur,int depth){
        //2.确定终止条件
        //3.确定单层递归逻辑
        //这个递归里面的终止条件和单层递归逻辑是在一起的
        //如果进入了迭代，深度就要加1
        depth++;
        //同时更新为最大的深度
        result = depth > result ? depth : result;
        //中
        //判断是否到叶子节点了
        if(cur.left == null && cur.right == null) return;

        //左
        if(cur.left != null){
            getDepth(cur.left,depth);
        }
        //右
        if(cur.right != null){
            getDepth(cur.right,depth);
        }
    }
    public int maxDepth(TreeNode root) {
        //初始化深度变量
        result = 0;
        //判断特殊情况
        if(root == null) return 0;
        //开始递归
        getDepth(root,0);
        return result;
    }
}

3.2.2 广度优先遍历+迭代法+借助队列：官方题解

class Solution {
    public int maxDepth(TreeNode root) {
        //广度优先遍历（BFS） 迭代法 借助队列
        //创建队列，存储迭代过程中的节点
        Queue<TreeNode> queue = new LinkedList<>();
        //判断特殊情况
        if(root != null) queue.offer(root);
        //创建变量，记录迭代的层数，就是树的深度
        int depth = 0;
        //开始迭代
        while(!queue.isEmpty()){
            //获取每一层的结点数
            int size = queue.size();
            //开始迭代每一层
            for(int i =0;i<size;i++){
                TreeNode cur = queue.poll();
                if(cur.left != null) queue.offer(cur.left);
                if(cur.right != null) queue.offer(cur.right);
            }
            //迭代完每一层深度加1
            depth++;
        }
        //迭代完毕，返回结果
        return depth;
    }
}

3.3 练习：559. N 叉树的最大深度

LeetCode难度标签：简单

3.3.1 题目描述

给定一个 N 叉树，找到其最大深度。

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

N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

示例 1：

img

输入：root = [1,null,3,2,4,null,5,6]
输出：3

示例 2：

img

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：5

提示：

  • 树的深度不会超过 1000 。
  • 树的节点数目位于 [0, 104] 之间。

3.3.2 题解

注意：N叉树的结点定义和二叉树的不同

深度优先搜索
/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
    public int maxDepth(Node root) {
        if (root == null) {
            return 0;
        }
        int maxChildDepth = 0;
        List<Node> children = root.children;
        for (Node child : children) {
            int childDepth = maxDepth(child);
            maxChildDepth = Math.max(maxChildDepth, childDepth);
        }
        return maxChildDepth + 1;
    }
}
广度优先搜索
/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
    public int maxDepth(Node root) {
        if (root == null) {
            return 0;
        }
        Queue<Node> queue = new LinkedList<Node>();
        queue.offer(root);
        int ans = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size > 0) {
                Node node = queue.poll();
                List<Node> children = node.children;
                for (Node child : children) {
                    queue.offer(child);
                }
                size--;
            }
            ans++;
        }
        return ans;
    }
}

4.111. 二叉树的最小深度

LeetCode难度标签：简单

4.1 题目说明

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

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

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

示例 1：

img

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

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

提示：

  • 树中节点数的范围在 [0, 105] 内
  • -1000 <= Node.val <= 1000

4.2 题解

  • 不知道大家做这道题目的情况如何，毛毛张一开始就是这种解法，被上面一题求最大深度给带偏了，把问题想简单了
  • 在求解的这道题目的时候不能单纯的取左右子树的最小深度，因为对于左斜树和右斜树来说是不适用的，另外一个子树的深度为零，这样计算返回这棵树的深度永远是1，因此需要对这两种情况单独考虑
    image-20240602191634373

4.2.1 深度优先搜索

4.2.1 递归法错解
class Solution {
    //递归法 三步走
    //1.确定形参和方法值：使用题目确定的形参和方法值
    public int minDepth(TreeNode root) {
        //2.确定终止条件
        if(root == null) return 0;

        //3.确定单层递归逻辑
        //左边的高度
        int leftDepth = minDepth(root.left);
        //右边的高度
        int rightDepth = minDepth(root.right);
        //以该节点为根节点的树的高度
        return 1 + Math.min(leftDepth,rightDepth);
    }
}
4.2.2 递归法正解
class Solution {
    //递归法 三步走
    //1.确定形参和返回值：使用题目确定的形参和返回值
    public int minDepth(TreeNode root) {
        //2.确定终止条件
        //和求二叉树的最大深度一样
        if (root == null) return 0;

        //3.确定单层递归逻辑
        //这里和求二叉树的最大深度不一样
        int leftDepth = minDepth(root.left);
        int rightDepth = minDepth(root.right);
        //右斜树的深度
        if (root.left == null) {
            return rightDepth + 1;
        }
        //左斜树的深度
        if (root.right == null) {
            return leftDepth + 1;
        }
        //既不左斜，也不右斜
        return Math.min(leftDepth, rightDepth) + 1;
    }
}

4.2.2 广度优先搜索：迭代法

class Solution {
    public int minDepth(TreeNode root) {
        //广度优先遍历（BFS） 迭代法 借助队列
        //创建队列，存储迭代过程中的节点
        Queue<TreeNode> queue = new LinkedList<>();
        //判断特殊情况
        if(root != null) queue.offer(root);
        //创建变量，记录迭代的层数，就是树的深度
        int depth = 0;
        //开始迭代
        while(!queue.isEmpty()){
            //获取每一层的结点数
            int size = queue.size();
            //迭代每一层深度加1
            depth++;
            //开始迭代每一层
            for(int i =0;i<size;i++){
                TreeNode cur = queue.poll();
                //遍历过程中遇到叶子节点就返回结果
                if(cur.left == null && cur.right == null) return depth;
                if(cur.left != null) queue.offer(cur.left);
                if(cur.right != null) queue.offer(cur.right);
            }
        }
        return depth;
    }
}

5.练习

5.1 二叉树叶子节点个数

题目描述：求二叉树的叶子结点数量

方法1： 递归 + 遍历思路

class Solution {
    int leafCount = 0;
    //递归法 三步走
    //1.使用题目确定的形参和返回值
    public int getLeafNodeNum(TreeNode root) {
        //2.确定终止条件
        if(root == null) {
            return 0;
        }
        //3.确定单层递归逻辑
        // 左右都空 是叶子
        if(root.left == null && root.right == null) {
            leafCount++;
        }
        getLeafNodeNum(root.left);
        getLeafNodeNum(root.right);
        return leafCount;
    }
}

方式2： 递归 + 子问题思路

class Solution {
    //递归法 三步走
    //1.使用题目确定的形参和返回值
    public int getLeafNodeNum(TreeNode root) {
        //2.确定终止条件
        if(root == null) {
            return 0;
        }
        //3.确定单层递归逻辑
        //左右都空是叶子
        if(root.left == null && root.right == null) {
            return 1;
        }
        return getLeafNodeNum(root.left) + getLeafNodeNum(root.right);
    }
}

5.2 二叉树第K层结点个数

class Solution {
    //递归法 三步走
    //1.使用题目确定的形参和返回值
    public int getKLevelNodeNum(TreeNode root, int k) {
        //2.确定终止条件
        if(root == null || k <= 0) {
            return 0;
        }
        if(k == 1) { // 第一层
            return 1;
        }
        
        //3.确定单层递归逻辑
        return getKLevelNodeNum(root.left, k - 1) + getKLevelNodeNum(root.right, k - 1);
    }
}

参考文献

神马都会亿点点的毛毛张
关注
  • 22
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
leetcode分类-leetcode:leetcode刷题笔记
06-30
《LeetCode刷题笔记》是针对编程爱好者和准备面试的开发者们的一份宝贵资源，它按照问题类型进行了精心分类，涵盖了LeetCode这个在线编程平台上的众多挑战。LeetCode以其丰富的算法题目和实际编程问题，成为了提升...
Leetcode刷题笔记 | 二叉树基本性质 | 一天的题量 | 5道题目 | 深度优先搜索 | 广度优先搜索 | 递归 | 遍历 | Java
神马都会亿点点的毛毛张
06-28 1150
🙋大家好！我是毛毛张!🌈个人首页：神马都会亿点点的毛毛张📌本期毛毛张分享的是LeetCode关于二叉树🌲的性质的一些基础题，做这些题目的本质还是遍历二叉树🏃‍➡️的过程，如果还不熟悉二叉树的遍历方法的同学可以先看看毛毛张的这篇文章➡️。
二叉树的构造问题 | LeetCode刷题笔记 | 每日练习 | 深度优先遍历| 广度优先遍历 | Java
最新发布
神马都会亿点点的毛毛张
07-21 901
毛毛张在前面已经分享过三期关于树的LeetCode算法题了：二叉树的题目的解法大多数可以从两个角度来解决：下面的四道题目不是很难，毛毛张主要讲解算法思路，前面连体可以参看毛毛张在关于二叉树的知识介绍中有跟详细的讲解给定两个整数数组 和 ，其中 是二叉树的中序遍历， 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。示例 1: 示例 2: 提示: 1.2.1.2 方法2(推荐) 1.2.1.3 方法3 1.2.1.4 总结 方法1和方法2的本质是一样的，区别在于写递归函数的时候是否再用题目默
LeetCode刷题笔记：二叉树前序遍历、中序遍历、后序遍历和层序遍历 | 递归法 | 迭代法 | 统一迭代法 | 深度优先搜索 | 广度优先搜索
神马都会亿点点的毛毛张
05-18 820
Problem:144. 二叉树的前序遍历Problem:94.二叉树的中序遍历Problem:145.二叉树的后序遍历Problem:102. 二叉树的层序遍历Problem:107. 二叉树的层序遍历 II二叉树的遍历方式有多种，毛毛张今天在这里结合代码随想录的教程来分享一下二叉树的多种遍历方式及代码实现深度优先遍历和广度优先遍历。
LeetCode刷题笔记 二叉树 二叉树的属性
王清欢的博客
11-13 2574
​ 最为常见的树就是二叉树，这种树的每个节点最多有两个子节点，二叉树可以看成是单链表的升级版，因为他和链表的主要区别就是多了一个子节点的指针。 Definition for a binary tree node. struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNode
LeetCode刷题笔记：105.从前序与中序遍历序列构造二叉树
hutianle的博客
08-02 73
二叉树构造问题
二叉树 | 递归遍历 | 递归知识点总结 | leecode刷题笔记
qq_44250700的博客
08-10 241
跟随carl代码随想录刷题 语言：python。
Leetcode刷题笔记——二叉树篇
qq_42898642的博客
02-19 892
本文给大家总结了二叉树中的DFS，二叉树本身就是一种递归定义的数据结构，所以二叉树和DFS是紧密相关的，其中的递归思想又诞生了很多衍生题，比如大多数的网格问题都可以看成是二叉树问题的一种变体【四叉结构】，这不是靠死记硬背就能解决的，需要大家在熟悉二叉树的性质的同时对类相关知识点的串联分析，这正好是很多大厂面试中面试官特别喜欢考察的面试者的点，最后，新的一年祝大家学习，工作一切顺利，找到心仪的offer，跳槽涨薪double，迎娶白富美，早日走向人生巅峰~
LeetCode刷题笔记：165.输出二叉树
hutianle的博客
08-22 152
给你一棵二叉树的根节点 root ，请你构造一个下标从 0 开始、大小为 m x n 的字符串矩阵 res ，用以表示树的 格式化布局。返回构造得到的矩阵 res。
LeetCode刷题笔记：543.二叉树的直径
hutianle的博客
03-09 290
LeetCode刷题笔记
leetcode:leetcode刷题笔记
04-06
"二叉树的前序遍历"、"二叉树的中序遍历"、"二叉树的后序遍历"等题目，是理解树结构和递归的好例子。 3. 排序与搜索：Python的`sort()`函数和`sorted()`函数可以方便地进行排序，而二分查找在"寻找两个有序数组的中...
leetcode刷题笔记之JavaScript
11-08
leetcode刷题笔记之JavaScript LeetCode刷题笔记之JavaScript知识分享 在本篇文章中，我们将讨论LeetCode中的二叉树、数组、链表、哈希表、栈、队列、图等数据结构和算法题目，并提供相应的JavaScript解决方案。 ...
leetcode亲密字符串-leetcode-js:js算法学习笔记(leetcode刷题)
07-06
js算法学习笔记(leetcode刷题) 刷题线路 链表 链表访问 141.环形链表 142.环形链表II 202.快乐数 链表反转 206.反转链表 92.反转链表II 25.K个一组反转链表 61.旋转链表 24.两两交换链表的节点 链表删除 19.删除链表...
stack(leetcode练习题)
2301_81692739的博客
07-19 380
最开始写的，总会有一些样例过不了，没考虑全，后来看题解上的方法，将下标压入栈中，用右括号的下标减去栈顶下标，就是有效长度。不然只顾着最长，反而无法得到正确的有效长度。一个完整的括号，要么是1，要么里边包含其他括号，进行了 *2。所以，可以每遇到一个右括号，进行一次运算，第一次为 1，以后每次乘二，累加到栈顶。遇到左括号，就向栈压入0，重新运算，当遇到右括号，再弹出.如果数字比栈顶小就压入，否则，将栈顶删除直到，比栈顶小或这栈为空。关于stack的知识，可以看点击查看上面的博客，以下题目全在。
【LeetCode】分隔链表
qq_26521261的博客
07-20 323
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
LeetCode 188题： 买卖股票的最佳时机IV优化（原创）
it_fly的专栏
07-21 146
算法思路：1.买了j次的最大获利值等于：昨天买了j次，和昨天卖了j-1次，今天再买的最大值；2.卖了j次的最大获利值等于：昨天卖了j次，和昨天买了j次，今天再卖掉的最大值
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 292
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

神马都会亿点点的毛毛张

你的鼓励将是我创作的最大动力!

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值