代码随想录 二叉树第三周

已于 2024-03-05 20:59:18 修改
阅读量736 收藏 15
点赞数 12
分类专栏： 代码随想录 文章标签： 算法 java 数据结构 leetcode 深度优先
于 2024-03-03 00:01:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74267125/article/details/136405558
版权

目录

404.左叶子之和

513.找树左下角的值

112.路径总和

106.从中序与后序遍历构造二叉树

105.从前序与中序遍历序列构造二叉树

654.最大二叉树

404.左叶子之和

404. 左叶子之和

简单

给定二叉树的根节点 root ，返回所有左叶子之和。

示例 1：

输入: root = [3,9,20,null,null,15,7] 
输出: 24 
解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

示例 2:

输入: root = [1]
输出: 0

提示:

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

递归法

 定义一个前驱指针指向要处理的节点的父节点，此时可判断该节点是否是左子节点

/**
 * Definition for a binary tree node.
 * 二叉树节点的定义
 * public class TreeNode {
 *     int val; // 节点值
 *     TreeNode left; // 左子节点
 *     TreeNode right; // 右子节点
 *     TreeNode() {} // 默认构造函数
 *     TreeNode(int val) { this.val = val; } // 带值的构造函数
 *     TreeNode(int val, TreeNode left, TreeNode right) { // 带值和子节点的构造函数
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    // 计算左叶子节点的和
    public int sumOfLeftLeaves(TreeNode root) {
        // 初始调用 leftLeavesSum 方法，传入 null 作为前一个节点
        int sum = leftLeavesSum(null, root); 
        return sum; // 返回左叶子节点的和
    }
    
    // 递归计算左叶子节点的和
    public int leftLeavesSum(TreeNode pre, TreeNode root) {
        if(root == null){ // 如果当前节点为空，返回 0
            return 0;
        }
        int middleSum = 0; // 用于累加左叶子节点的和
        // 如果当前节点是左叶子节点且前一个节点不为空且是当前节点的父节点
        if(root.left == null && root.right == null && pre != null && pre.left == root){
            middleSum += root.val; // 将当前节点值加入到左叶子节点的和中
            return middleSum; // 返回当前节点值作为左叶子节点的和
        }
        // 递归计算左子树的左叶子节点的和
        int leftSum = leftLeavesSum(root, root.left);
        // 递归计算右子树的左叶子节点的和
        int rightSum = leftLeavesSum(root, root.right);
        // 返回左叶子节点的和，包括左子树、右子树和当前节点的和
        return middleSum + leftSum + rightSum;
    }
}

迭代法

// 层序遍历迭代法
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        int sum = 0; // 初始化左叶子节点的和
        if (root == null) return 0; // 如果根节点为空，返回0
        Queue<TreeNode> queue = new LinkedList<>(); // 创建一个队列用于层序遍历
        queue.offer(root); // 将根节点加入队列
        while (!queue.isEmpty()) { // 当队列不为空时，继续遍历
            int size = queue.size(); // 获取当前层的节点数
            while (size-- > 0) { // 遍历当前层的所有节点
                TreeNode node = queue.poll(); // 从队列中取出一个节点
                if (node.left != null) { // 如果左节点不为空
                    queue.offer(node.left); // 将左节点加入队列
                    if (node.left.left == null && node.left.right == null){ // 判断左节点是否为叶子节点
                        sum += node.left.val; // 如果是左叶子节点，则将其值加入到和中
                    }
                }
                if (node.right != null) queue.offer(node.right); // 将右节点加入队列
            }
        }
        return sum; // 返回左叶子节点的和
    }
}

513.找树左下角的值

513. 找树左下角的值

中等

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

假设二叉树中至少有一个节点。

示例 1:

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

示例 2:

输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

提示:

  • 二叉树的节点个数的范围是 [1,104]
  • -231 <= Node.val <= 231 - 1 

递归法： 

同一深度的情况下，由于左子树先于右子树遍历，故左侧节点先被更新到value中，而同一层其他节点不会被更新

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

// 解题思路：
// 使用深度优先搜索（DFS）来遍历二叉树，记录最左侧叶子节点的值以及其深度，
// 若当前叶子节点的深度大于已记录的最大深度，则更新最左侧叶子节点的值和深度，
// 最终返回最左侧叶子节点的值。

class Solution {
    int maxDepth = -1; // 初始化最大深度为-1
    int value = 0; // 初始化最左侧叶子节点的值为0
    
    public int findBottomLeftValue(TreeNode root) {
        leftValue(root, 0); // 调用递归函数
        return value; // 返回最左侧叶子节点的值
    }
    
    // 递归函数，用于寻找最左侧叶子节点的值
    public void leftValue(TreeNode root, int depth) {
        if (root == null) { // 如果当前节点为空，直接返回
            return;
        }
        if (root.left == null && root.right == null && depth > maxDepth) { // 当前节点为叶子节点且深度大于最大深度
            value = root.val; // 更新最左侧叶子节点的值
            maxDepth = depth; // 更新最大深度
        }
        leftValue(root.left, depth + 1); // 递归遍历左子树，深度加1
        leftValue(root.right, depth + 1); // 递归遍历右子树，深度加1
    }
}

 迭代法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {  
  
    // findBottomLeftValue方法，接受一个二叉树的根节点作为参数，返回最底层最左边节点的值。  
    public int findBottomLeftValue(TreeNode root) {  
        // 创建一个队列，用于层序遍历二叉树。  
        Queue<TreeNode> queue = new LinkedList<>();  
        // 将根节点加入队列。  
        queue.offer(root);  
        // 初始化结果变量，用于存储最底层最左边节点的值。  
        int res = 0;  
  
        // 当队列不为空时，进行循环。  
        while (!queue.isEmpty()) {  
            // 获取当前层的节点数量。  
            int size = queue.size();  
            // 遍历当前层的所有节点。  
            for (int i = 0; i < size; i++) {  
                // 取出队列中的一个节点。  
                TreeNode poll = queue.poll();  
                // 如果是当前层的第一个节点（即最左边的节点），则更新结果变量的值。  
                if (i == 0) {  
                    res = poll.val;  
                }  
                // 如果该节点有左子节点，则将左子节点加入队列。  
                if (poll.left != null) {  
                    queue.offer(poll.left);  
                }  
                // 如果该节点有右子节点，则将右子节点加入队列。  
                if (poll.right != null) {  
                    queue.offer(poll.right);  
                }  
            }  
        }  
        // 返回结果变量的值，即最底层最左边节点的值。  
        return res;  
    }  
}

112.路径总和

112. 路径总和

简单

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：

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

 递归法：

 采用前序遍历，没到一个节点就将targetSum减去该节点的val，如果是根节点的话判断条件并返回，不是根节点的话向左右子树遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
// 定义一个Solution类  
class Solution {  
      
    // hasPathSum方法，接受一个二叉树的根节点root和一个目标值targetSum作为参数  
    // 返回值为boolean类型，表示是否存在从根节点到叶子节点的路径，使得路径上所有节点的值之和等于targetSum  
    public boolean hasPathSum(TreeNode root, int targetSum) {  
          
        // 如果根节点为空（即二叉树为空树），则不存在任何路径，返回false  
        if(root == null){  
            return false;  
        }  
          
        // 从目标值中减去当前节点的值，更新目标值  
        targetSum -= root.val;  
          
        // 如果当前节点是叶子节点（即没有左子节点和右子节点）  
        if(root.left == null && root.right == null){  
            // 如果更新后的目标值为0，说明从根节点到当前叶子节点的路径上所有节点的值之和正好等于targetSum  
            if(targetSum == 0){  
                return true;  
            }else{  
                // 如果不等于0，则说明不存在符合条件的路径，返回false  
                return false;  
            }   
        }  
          
        // 如果当前节点不是叶子节点，则递归地对左子树和右子树调用hasPathSum方法  
        // leftResult表示左子树中是否存在符合条件的路径  
        boolean leftResult = hasPathSum(root.left,targetSum);  
        // rightResult表示右子树中是否存在符合条件的路径  
        boolean rightResult = hasPathSum(root.right,targetSum);  
          
        // 如果左子树或右子树中存在符合条件的路径，则返回true；否则返回false  
        return leftResult || rightResult;  
    }  
}

 迭代法：

// 定义一个Solution类  
class Solution {  
      
    // hasPathSum方法，接受一个二叉树的根节点root和一个目标值targetSum作为参数  
    // 返回值为boolean类型，表示是否存在从根节点到叶子节点的路径，使得路径上所有节点的值之和等于targetSum  
    public boolean hasPathSum(TreeNode root, int targetSum) {  
          
        // 如果根节点为空（即二叉树为空树），则不存在任何路径，返回false  
        if(root == null){  
            return false;  
        }  
          
        // 创建两个队列，一个用于存储节点，另一个用于存储从根节点到当前节点的路径和  
        Queue<TreeNode> treeNode = new LinkedList<>();  
        Queue<Integer> count = new LinkedList<>();  
          
        // 将根节点和初始的路径和（即目标值）加入队列  
        treeNode.offer(root);  
        count.offer(targetSum);  
          
        // 使用while循环进行层序遍历，直到节点队列或路径和队列为空  
        while(!treeNode.isEmpty() && !count.isEmpty()){  
              
            // 取出队列中的节点和对应的路径和  
            TreeNode node = treeNode.poll();  
            int countRes = count.poll() - node.val; // 更新路径和，减去当前节点的值  
              
            // 如果当前节点是叶子节点（即没有左子节点和右子节点），并且路径和等于0  
            // 则说明找到了一个从根节点到叶子节点的路径，其路径上所有节点的值之和等于targetSum  
            if(node.left == null && node.right == null && countRes == 0){  
                return true;  
            }  
              
            // 如果当前节点有左子节点，则将左子节点和更新后的路径和加入队列  
            if(node.left != null){  
                treeNode.offer(node.left);  
                count.offer(countRes);  
            }  
              
            // 如果当前节点有右子节点，则将右子节点和更新后的路径和加入队列  
            if(node.right != null){  
                treeNode.offer(node.right);  
                count.offer(countRes);  
            }  
        }  
          
        // 如果遍历完所有节点后仍未找到符合条件的路径，则返回false  
        return false;  
    }  
}

106.从中序与后序遍历构造二叉树

106. 从中序与后序遍历序列构造二叉树

已解答

中等

相关标签

相关企业

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

示例 1:

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

示例 2:

输入：inorder = [-1], postorder = [-1]
输出：[-1]

提示:

  • 1 <= inorder.length <= 3000
  • postorder.length == inorder.length
  • -3000 <= inorder[i], postorder[i] <= 3000
  • inorder 和 postorder 都由 不同 的值组成
  • postorder 中每一个值都在 inorder 中
  • inorder 保证是树的中序遍历
  • postorder 保证是树的后序遍历
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        //因为每次都从postorder中取元素，所以当postorder为空的时候就返回null
        if(postorder.length == 0){
            return null;
        } 
        //取后序遍历的最后一个节点，即中，作为节点元素
        int nodeValue = postorder[postorder.length - 1];
        TreeNode node = new TreeNode(nodeValue);
        //找到后序数组最后一个元素在中序数组中的位置，即中间节点的位置，作为切割点
        int middleindex;
        for(middleindex = 0;middleindex < postorder.length - 1; middleindex ++){
            if(inorder[middleindex] == nodeValue){
                break;
            }
        }
        //切割中序数组，找到左子树的中序数组和右子树的中序数组
        //中间节点之前的，即左子树
        int[] leftInorder = Arrays.copyOfRange(inorder,0,middleindex);
        //中间节点之后的，即右子树
        int[] rightInorder = Arrays.copyOfRange(inorder,middleindex + 1,inorder.length);

        //切割后序数组，找到左子树的后序数组和右子树的后序数组
        //删除已经操作过的后序数组的最后一个元素
        postorder = Arrays.copyOfRange(postorder,0,postorder.length - 1);
        int[] leftPostorder = Arrays.copyOfRange(postorder,0,middleindex);
        int[] rightPostorder = Arrays.copyOfRange(postorder,middleindex,postorder.length);

        // 递归地构建左子树和右子树，并将它们分别设置为当前节点的左孩子和右孩子
        node.left = buildTree(leftInorder,leftPostorder);
        node.right = buildTree(rightInorder,rightPostorder);
        return node;
    }
}

105.从前序与中序遍历序列构造二叉树

105. 从前序与中序遍历序列构造二叉树

中等

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

示例 2:

输入: preorder = [-1], inorder = [-1]
输出: [-1]

提示:

  • 1 <= preorder.length <= 3000
  • inorder.length == preorder.length
  • -3000 <= preorder[i], inorder[i] <= 3000
  • preorder 和 inorder 均 无重复 元素
  • inorder 均出现在 preorder
  • preorder 保证 为二叉树的前序遍历序列
  • inorder 保证 为二叉树的中序遍历序列
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        //由于每次都是从前序数组中取元素，当前序数组为空时，返回null
        if(preorder.length == 0){
            return null;
        }
        //当前序数组不为空时，从中取得第一个元素作为中间节点
        int nodeValue = preorder[0];
        TreeNode node = new TreeNode(nodeValue);

        //找到该中间节点（即第一个元素）在中序数组中的位置
        int middleIndex;
        for(middleIndex = 0;middleIndex < inorder.length - 1;middleIndex ++){
            if(inorder[middleIndex] == nodeValue){
                break;
            }
        }
        //切割中序数组，分为左子树的中序数组和右子树的中序数组
        int[] leftInorder = Arrays.copyOfRange(inorder,0,middleIndex);
        int[] rightInorder = Arrays.copyOfRange(inorder,middleIndex + 1,inorder.length);

        //切割前序数组，分为左子树的前序数组和右子树的前序数组
        //先删除数组中已经取出的中间节点
        preorder = Arrays.copyOfRange(preorder,1,preorder.length);
        int[] leftPreorder = Arrays.copyOfRange(preorder,0,middleIndex);
        int[] rightPreorder = Arrays.copyOfRange(preorder,middleIndex,preorder.length);
        
        // 递归地构建左子树和右子树，并将它们分别设置为当前节点的左孩子和右孩子
        node.left = buildTree(leftPreorder,leftInorder);
        node.right = buildTree(rightPreorder,rightInorder);
        return node;
    }
}

654.最大二叉树

654. 最大二叉树

中等

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

  1. 创建一个根节点，其值为 nums 中的最大值。
  2. 递归地在最大值 左边 的 子数组前缀上 构建左子树。
  3. 递归地在最大值 右边 的 子数组后缀上 构建右子树。

返回 nums 构建的 最大二叉树 。

示例 1：

输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
解释：递归调用如下所示：
- [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。
    - [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
        - 空数组，无子节点。
        - [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。
            - 空数组，无子节点。
            - 只有一个元素，所以子节点是一个值为 1 的节点。
    - [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。
        - 只有一个元素，所以子节点是一个值为 0 的节点。
        - 空数组，无子节点。

示例 2：

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

提示：

  • 1 <= nums.length <= 1000
  • 0 <= nums[i] <= 1000
  • nums 中的所有整数 互不相同
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {  
    // 返回构建好的最大二叉树的根节点  
    public TreeNode constructMaximumBinaryTree(int[] nums) {  
          
        // 如果数组为空，则返回null，因为不能构建二叉树  
        if(nums.length == 0){  
            return null;  
        }  
          
        // 初始化最大值和最大值的索引为-1和0  
        int max = -1;  
        int maxIndex = 0;  
          
        // 遍历数组，找到最大值及其索引  
        for(int i = 0; i < nums.length; i++){  
            if(nums[i] > max){  
                max = nums[i];  
                maxIndex = i;  
            }  
        }  
          
        // 创建一个新的树节点，值为数组中的最大值  
        TreeNode node = new TreeNode(max);  
          
        // 使用Arrays类的copyOfRange方法，复制最大值左边的部分数组作为左子树的输入数组  
        int[] leftNums = Arrays.copyOfRange(nums, 0, maxIndex);  
          
        // 使用Arrays类的copyOfRange方法，复制最大值右边的部分数组作为右子树的输入数组  
        int[] rightNums = Arrays.copyOfRange(nums, maxIndex + 1, nums.length);  
          
        // 递归地构建左子树和右子树，并将它们分别设置为当前节点的左孩子和右孩子  
        node.left = constructMaximumBinaryTree(leftNums);  
        node.right = constructMaximumBinaryTree(rightNums);  
          
        // 返回构建好的最大二叉树的根节点  
        return node;  
    }  
}

这个方法是上面方法的优化，通过索引来操作，不需要新建数组 

注意下边这种方法传索引的方式都是左闭右闭

class Solution {  
    // 外部接口方法，用于构建最大二叉树并返回其根节点  
    public TreeNode constructMaximumBinaryTree(int[] nums) {  
        // 调用辅助方法，传入数组和边界索引  
        return construct(nums, 0, nums.length - 1);  
    }  
  
    // 辅助方法，递归地构建最大二叉树  
    private TreeNode construct(int[] nums, int left, int right) {  
        // 如果左边界大于右边界，说明当前子数组为空，返回null 
        //这里传入的是左闭右闭的索引区间 
        if (left > right) {  
            return null;  
        }  
  
        // 初始化最大值和最大值索引  
        int max = Integer.MIN_VALUE; // 初始化为最小整数值，确保能够找到数组中的最大值  
        int maxIndex = left; // 初始化索引为左边界，确保至少能找到左边界的值  
  
        // 遍历数组，找到最大值及其索引  
        for (int i = left; i <= right; i++) {  
            if (nums[i] > max) {  
                max = nums[i]; // 更新最大值  
                maxIndex = i; // 更新最大值的索引  
            }  
        }  
  
        // 创建一个新的树节点，值为数组中的最大值  
        TreeNode node = new TreeNode(max);  
  
        // 递归地构建左子树和右子树  
        // 左子树由最大值左边的部分数组构建，右边界为最大值索引  
        // 右子树由最大值右边的部分数组构建，左边界为最大值索引+1  
        node.left = construct(nums, left, maxIndex - 1);  
        node.right = construct(nums, maxIndex + 1, right);  
  
        // 返回构建好的最大二叉树的根节点  
        return node;  
    }  
}

XiaoMing_Coder
关注
  • 12
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录——二叉树 刷题记录
qq_43541423的博客
03-22 2029
因为是二叉搜索树，所以需要对比当前节点和pq的节点值，如果当前小于pq则在右子树中寻找，如果当前大于pq则从左子树寻找，如果刚好在pq之间，则该节点就是最近公共祖先。注意当其中一个树的节点不存在时，直接返回存在的节点（带着孩子）就好，不需要新建节点，如果新建节点，则该节点后续孩子还需要处理。一定注意返回值，返回树的根节点，那么当该节点不是删除的节点时，需要改变左右孩子进行递归然后返回自身。处理节点的左孩子时，如果左孩子节点删除，则需要该节点的左孩子定位到原来左孩子的右孩子，可以多做几遍。
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
《代码随想录》是一本深受程序员喜爱的编程学习资料，尤其在算法领域，它提供了丰富的实例和深入的解析，帮助读者理解并掌握动态规划、回溯、递归、二叉树以及贪心等核心算法。这些算法是解决复杂计算问题的基础工具...
代码随想录 二叉树第四周
m0_74267125的博客
03-04 934
简单给你两棵二叉树：root1和root2。想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，null 的节点将直接作为新二叉树的节点。返回合并后的二叉树。合并过程必须从两个树的根节点开始。
代码随想录 二叉树第二周
m0_74267125的博客
03-01 704
的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。是指从根节点到最远叶子节点的最长路径上的节点数。的左右两个子树的高度差的绝对值不超过 1。的某个节点和这个节点的所有后代节点。，返回所有从根节点到叶子节点的路径。叶子节点是指没有子节点的节点。
代码随想录 二叉树第一周
m0_74267125的博客
02-28 283
前序遍历是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子。 为什么要先加入 右孩子，再加入左孩子呢？ 因为这样出栈的时候才是中左右的顺序。
代码随想录——二叉树
weixin_44479862的博客
08-31 291
二叉树
代码随想录-二叉树（基础理论）
希希雾里
02-28 833
代码随想录-二叉树
代码随想录二叉树 Java（三）
guliguliguliguli的博客
06-15 741
显然，p和q的最近公共祖先就是从根节点到它们路径上的【分岔点】，也就是最后一个相同的节点。一个一个删除太繁琐了。表示，x节点的左孩子和右孩子均包含p节点或q节点，如果左子树包含的是p节点，那么右子树只能包含q节点，反之亦然，因为p和q节点都是不同且唯一的节点，因此，如果满足这个条件，就可以说x是最近的公共祖先。如果根节点不为空，则将val从根节点开始比较，如果val的值大于根节点的值，则移动到该二叉树的右节点，如果val的值小于根节点，则移动到该二叉树的左节点，并使用一个变量pre记录当前节点的父节点。
代码随想录-二叉树
XYY_CN的博客
11-26 477
中序遍历与前序遍历不同的点在于push_back val的时机，前序遍历时第一次碰到的就是中节点，直接push_back。而中序遍历是在遍历完所有左节点之后,访问到的节点认为是目标值节点。非迭代的普通写法中需要注意右节点重复的情况。
代码随想录二叉树——完全二叉树的节点个数
qq_39473176的博客
09-22 534
刷题总结
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
「代码随想录」二叉树专题精讲（v1.2）.pdf
12-14
"代码随想录二叉树专题精讲" 本资源是关于二叉树的专题讲解，涵盖了二叉树的基本概念、avl树、红黑树、堆、trie树等多种二叉树结构的实现和应用。 知识点一：二叉树的基本概念 二叉树是一种特殊的树状结构，它的每...
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 3330
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
算法 —— 暴力枚举
最新发布
fen_0108的博客
07-25 3914
第二看纵向宽发生改变，长重置为1，长为1，宽为2的时候，第一行个数为7个，总共有5 x 7 个，长为2，宽为2的时候 第一行个数为6个，共有5 x 6个……首先是横着的长方形，宽始终为1，长不断发生改变，可以看出长为2的时候，第一行个数为6个，总共有6 x 6个，长为3的时候，总共有6 x 5个……这是一道简单的模拟题，枚举出所有可能情况，不会超过规定时间的，以下附上k
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 1587
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
2024.7.24 作业
qq_64434282的博客
07-24 2691
【代码】2024.7.24 作业。
代码随想录算法训练营
08-23
代码随想录算法训练营是一个优质的学习和讨论平台，提供了丰富的算法训练内容和讨论交流机会。在训练营中，学员们可以通过观看视频讲解来学习算法知识，并根据讲解内容进行刷题练习。此外，训练营还提供了刷题建议，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值