您好,欢迎访问代理记账网站
  • 价格透明
  • 信息保密
  • 进度掌控
  • 售后无忧

leetcode刷穿二叉树(六)(终章)

终于在第六天拿下了二叉树

在这里插入图片描述

这里有leetcode题集分类整理!!!

今日目标:

  • leetcode 669. 修剪二叉搜索树
  • leetcode 108. 将有序数组转换为二叉搜索树
  • leetcode 538. 把二叉搜索树转换为累加树
  1. 修剪二叉搜索树
    题目难度:中等
    在这里插入图片描述
    在这里插入图片描述
    解题思路:

二叉搜索树的区间剪枝,根据题意,我们可以得知,满足如下条件的节点需要被‘剪掉’:
root.val < lowroot.val > high
只保留区间的值,不过这个‘剪掉’并不可以是直接将该不满足条件对节点置空,需要一直遍历到当前节点的孩子节点,使其孩子节点保证也在 [low,high] 之间。
确定递归结束的条件: 遇空返回
递归逻辑

  • 每次递归返回符合条件的节点
  • 将父节点与符合条件的节点进行重新组合返回
class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if (root == null) return null;
        if (root.val < low) return trimBST(root.right, low, high);
        if (root.val > high) return trimBST(root.left, low, high);
        root.left = trimBST(root.left, low, high);
        root.right = trimBST(root.right, low, high);
        return root;
    }
}
  1. 将有序数组转换为二叉搜索树
    题目难度:简单
    在这里插入图片描述
    在这里插入图片描述
    解题思路:

根据数组来构造二叉树在这篇文章的第一题里面做过比这个还要复杂一丢丢的了: leetcode刷穿二叉树(四),有兴趣可以去看一看。这里根据已给出的有序数组构造二叉树,只需要在递归创建的时候确定好左右孩子各属于什么边界,在进行递归就可以。
递归终止条件:

  • 用于确定孩子的数组左右边界相同,对应代码中的 left == right

递归逻辑:

  • 计算当前数组范围的rootIndex
  • 分别计算孩子节点位于数组的范围
  • 左右孩子同时递归对应的construct(nums, left, right)
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        int n = nums.length;
        return construct(nums, 0, n);
    }

    public TreeNode construct(int[] nums, int left, int right) {
    	// 数组为空返回
        if (left == right) return null;
        int rootIndex = left + right >> 1;
        TreeNode node = new TreeNode(nums[rootIndex]);
        // 递归创建节点
        node.left = construct(nums, left, rootIndex);
        node.right = construct(nums, rootIndex + 1, right);
        // 返回节点
        return node;
    }
}
  1. 把二叉搜索树转换为累加树
    题目难度:中等
    在这里插入图片描述
    在这里插入图片描述
    解题思路一(朴素):

看到这个题和这个图的一瞬间想到的是:把整个二叉树进行翻转然后再根据中序遍历去更新每个节点的值。 但是,又感觉挺麻烦的。
于是尝试了一下把二叉树上所有的数字记录下来,在叠加到数组里面,在根据中序遍历二叉树,对树节点的值进行更新。没想到一下就ac了。思路如下:

  • 中序遍历,将二叉树的数据遍历存储到数组(因为是BST,所以数组为升序数组)
  • 将数组的值进行倒序叠加,使得数组编程降序的累加和。
  • 中序遍历BST,对树上的值进行更新。

以上思路还有很多可以优化的地方在后面说,先给他A了:

class Solution {
    private int[] nums = new int[10005];
    private int count = 0;
    public TreeNode convertBST(TreeNode root) {
        inOrderTraversal(root);
        calcNums();
        count = 0;
        update(root);
        return root;
    }

    public void inOrderTraversal(TreeNode root) {
        if (root == null) return;
        inOrderTraversal(root.left);
        nums[count ++] = root.val;
        inOrderTraversal(root.right);
    }

    public void calcNums() {
        for (int i = count - 1; i >= 0; i --) {
            nums[i] = nums[i] + nums[i + 1];
        }
    }

    public void update(TreeNode root) {
        if (root == null) return;
        update(root.left);
        root.val = nums[count ++];
        update(root.right);
    }
}

解题思路二(反向中序遍历):

一开始想到肯定能优化不少,但是学的太死了,忘记了二叉树可以反向遍历,没想到可以优化成这样子 …
根前序解题思路一的初始思路一样,只不过是将二叉树翻转的过程改为反向遍历,少了两个步骤。 code如下:

class Solution {
    private int sum = 0;
    public TreeNode convertBST(TreeNode root) {
        if (root != null) {
            convertBST(root.right);
            sum += root.val;
            root.val = sum;
            convertBST(root.left);
        }
        return root;
    }
}

分享:

低价透明

统一报价,无隐形消费

金牌服务

一对一专属顾问7*24小时金牌服务

信息保密

个人信息安全有保障

售后无忧

服务出问题客服经理全程跟进