代码随想录算法训练营第二十二天丨二叉树part09

669. 修剪二叉搜索树

思路

递归法

从图中可以看出需要重构二叉树，想想是不是本题就有点复杂了。

其实不用重构那么复杂。

在上图中我们发现节点0并不符合区间要求，那么将节点0的右孩子节点2 直接赋给节点3的左孩子就可以了（就是把节点0从二叉树中移除），如图：

理解了最关键部分了我们再递归三部曲：

确定递归函数的参数以及返回值

这里我们为什么需要返回值呢？

因为是要遍历整棵树，做修改，其实不需要返回值也可以，我们也可以完成修剪（其实就是从二叉树中移除节点）的操作。

但是有返回值，更方便，可以通过递归函数的返回值来移除节点。

这样的做法在二叉树：搜索树中的插入操作 (opens new window)和二叉树：搜索树中的删除操作 (opens new window)中大家已经了解过了。

代码如下：

TreeNode trimNode(TreeNode cur, int low, int high)

确定终止条件

修剪的操作并不是在终止条件上进行的，所以就是遇到空节点返回就可以了。

if (cur == null){
    return null;
}

确定单层递归的逻辑

如果root（当前节点）的元素小于low的数值，那么应该递归右子树，并返回右子树符合条件的头结点。

代码如下：

// 寻找符合区间[low, high]的节点
if (cur.val < low){
    TreeNode right = trimNode(cur.right, low, high);
    return right;
}

如果root(当前节点)的元素大于high的，那么应该递归左子树，并返回左子树符合条件的头结点。

代码如下：

if (cur.val > high){
   TreeNode left = trimNode(cur.left,low,high);
   return left;
}

接下来要将下一层处理完左子树的结果赋给root->left，处理完右子树的结果赋给root->right。

最后返回root节点，代码如下：

cur.left = trimNode(cur.left,low,high);//cur.left接入符合条件的左孩子
cur.right = trimNode(cur.right,low,high);//cur.right接入符合条件的右孩子
return cur;

此时大家是不是还没发现这多余的节点究竟是如何从二叉树中移除的呢？

在回顾一下上面的代码，针对下图中二叉树的情况：

669.修剪二叉搜索树1

如下代码相当于把节点0的右孩子（节点2）返回给上一层，

// 寻找符合区间[low, high]的节点
if (cur.val < low){
    TreeNode right = trimNode(cur.right, low, high);
    return right;
}

然后如下代码相当于用节点3的左孩子把下一层返回的节点0的右孩子（节点2）接住。

cur.left = trimNode(cur.left,low,high);//cur.left接入符合条件的左孩子

此时节点3的左孩子就变成了节点2，将节点0从二叉树中移除了。

整体代码如下：

class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        return trimNode(root,low,high);
    }
    TreeNode trimNode(TreeNode cur, int low, int high){
        if (cur == null){
            return null;
        }
        // 寻找符合区间[low, high]的节点
        if (cur.val < low){
            TreeNode right = trimNode(cur.right, low, high);
            return right;
        }
        if (cur.val > high){
            TreeNode left = trimNode(cur.left,low,high);
            return left;
        }
        cur.left = trimNode(cur.left,low,high);//cur.left接入符合条件的左孩子
        cur.right = trimNode(cur.right,low,high);//cur.right接入符合条件的右孩子
        return cur;
    }
}

108.将有序数组转换为二叉搜索树

思路

题目中说要转换为一棵高度平衡二叉搜索树。为什么强调要平衡呢？

因为只要给我们一个有序数组，如果强调平衡，都可以以线性结构来构造二叉搜索树。

例如有序数组[-10，-3，0，5，9] 就可以构造成这样的二叉搜索树，如图。

上图中，是符合二叉搜索树的特性吧，如果要这么做的话，是不是本题意义就不大了，所以才强调是平衡二叉搜索树。

其实数组构造二叉树，构成平衡树是自然而然的事情，因为大家默认都是从数组中间位置取值作为节点元素，一般不会随机取。所以想构成不平衡的二叉树是自找麻烦。

本质就是寻找分割点，分割点作为当前节点，然后递归左区间和右区间。

分割点就是数组中间位置的节点。

那么为问题来了，如果数组长度为偶数，中间节点有两个，取哪一个？

取哪一个都可以，只不过构成了不同的平衡二叉搜索树。

例如：输入：[-10,-3,0,5,9]

如下两棵树，都是这个数组的平衡二叉搜索树：

如果要分割的数组长度为偶数的时候，中间元素为两个，是取左边元素就是树1，取右边元素就是树2。

递归

递归三部曲：

确定递归函数返回值及其参数

删除二叉树节点，增加二叉树节点，都是用递归函数的返回值来完成，这样是比较方便的。

相信大家如果仔细看了二叉树：搜索树中的插入操作 (opens new window)和二叉树：搜索树中的删除操作 (opens new window)，一定会对递归函数返回值的作用深有感触。

那么本题要构造二叉树，依然用递归函数的返回值来构造中节点的左右孩子。

再来看参数，首先是传入数组，然后就是左下标left和右下标right，我们在二叉树：构造二叉树登场！ (opens new window)中提过，在构造二叉树的时候尽量不要重新定义左右区间数组，而是用下标来操作原数组。

所以代码如下：

// 左闭右闭区间[left, right]
TreeNode sortTree(int[] nums,int left,int right)

这里注意，我这里定义的是左闭右闭区间，在不断分割的过程中，也会坚持左闭右闭的区间，这又涉及到我们讲过的循环不变量。

确定递归终止条件

这里定义的是左闭右闭的区间，所以当区间 left > right的时候，就是空节点了。

代码如下：

if (left > right){return null;}

确定单层递归的逻辑

首先取数组中间元素的位置，不难写出int mid = (left + right) / 2;，这么写其实有一个问题，就是数值越界，例如left和right都是最大int，这么操作就越界了，在二分法 (opens new window)中尤其需要注意！

所以可以这么写：int mid = left + ((right - left) / 2);

但本题leetcode的测试数据并不会越界，所以怎么写都可以。但需要有这个意识！

取了中间位置，就开始以中间位置的元素构造节点，代码：TreeNode cur = new TreeNode(nums[mid]); 。

接着划分区间，root的左孩子接住下一层左区间的构造节点，右孩子接住下一层右区间构造的节点。

最后返回root节点，单层递归整体代码如下：

int mid = (left+right) /2;
TreeNode cur = new TreeNode(nums[mid]);
cur.left = sortTree(nums,left,mid-1);
cur.right = sortTree(nums,mid+1,right);
return cur;

递归整体代码如下：

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return sortTree(nums,0, nums.length-1);
    }
    // 左闭右闭区间[left, right]
    TreeNode sortTree(int[] nums,int left,int right){
        if (left > right){return null;}
        int mid = (left+right) /2;
        TreeNode cur = new TreeNode(nums[mid]);
        cur.left = sortTree(nums,left,mid-1);
        cur.right = sortTree(nums,mid+1,right);
        return cur;
    }
}

538.把二叉搜索树转换为累加树

思路

如何累加？遇到一个节点，然后再遍历其他节点累加？

然后再发现这是一棵二叉搜索树，二叉搜索树啊，这是有序的啊。

那么有序的元素如何求累加呢？

其实这就是一棵树，大家可能看起来有点别扭，换一个角度来看，这就是一个有序数组[2, 5, 13]，求从后到前的累加数组，也就是[20, 18, 13]，是不是感觉这就简单了。

为什么变成数组就是感觉简单了呢？

因为数组大家都知道怎么遍历啊，从后向前，挨个累加就完事了，这换成了二叉搜索树，看起来就别扭了一些是不是。

那么知道如何遍历这个二叉树，也就迎刃而解了，从树中可以看出累加的顺序是右中左，所以我们需要反中序遍历这个二叉树，然后顺序累加就可以了。

#递归

遍历顺序如图所示：

本题依然需要一个pre指针记录当前遍历节点cur的前一个节点，这样才方便做累加。

pre指针的使用技巧，在二叉树：搜索树的最小绝对差 (opens new window)和二叉树：我的众数是多少？ (opens new window)都提到了，这是常用的操作手段。

递归函数参数以及返回值

这里很明确了，不需要递归函数的返回值做什么操作了，要遍历整棵树。

同时需要定义一个全局变量pre，用来保存cur节点的前一个节点的数值。

代码如下：

// 记录前一个节点的数值
TreeNode pre = new TreeNode(0);

确定终止条件

遇空就终止。

if (node == null){
    return null;
}

确定单层递归的逻辑

注意要右中左来遍历二叉树，中节点的处理逻辑就是让cur的数值加上前一个节点的数值。

代码如下：

//右
sumTree(node.right);
//中
node.val = node.val + pre.val;
pre = node;
//左
sumTree(node.left);
        
return node;

递归法整体代码如下：

class Solution {
    public TreeNode convertBST(TreeNode root) {
        return sumTree(root);
    }
    // 记录前一个节点的数值
    TreeNode pre = new TreeNode(0);
    //右中左
    TreeNode sumTree(TreeNode node){
        if (node == null){
            return null;
        }
        //右
        sumTree(node.right);
        //中
        node.val = node.val + pre.val;
        pre = node;
        //左
        sumTree(node.left);
        
        return node;
    }
}