代码随想录算法训练营第23天｜二叉树part09｜ 669. 修剪二叉搜索树、 108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树-CSDN博客

本文链接：https://blog.csdn.net/gengjiahao/article/details/131674667

代码随想录算法训练营第23天｜二叉树part09｜ 669. 修剪二叉搜索树、 108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树

669. 修剪二叉搜索树

之间看的视频讲解

代码随想录

思路：

本题注意的地方，就是不能直接删除不在区间内的结点，因为该结点的右子树中的结点有可能是在区间之内的，所以要去右子树中继续查找

在这里插入图片描述

如图所示，不能直接将0结点删除。

代码：

python

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def trimBST(self, root, low, high): # 1. 确定返回值和参数
        """
        :type root: TreeNode
        :type low: int
        :type high: int
        :rtype: TreeNode
        """
        # 2. 确定终止条件
        if root == None:
            return None
            
		# 3. 确定单层递归的逻辑
		# 如果当前的值小于low，那么其左子树一定可以删除，右子树不能删除可能含有在区间内的结点，所以要继续修剪其右子树
        if root.val < low:
            return self.trimBST(root.right, low, high)
        # 同理，要继续修剪其左子树    
        if root.val > high:
            return self.trimBST(root.left, low, high)
        
        # 修建完左右子树要得到返回的结果
        root.left = self.trimBST(root.left, low, high)
        root.right = self.trimBST(root.right, low, high) 
		
		# 返回根结点
        return root

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

自己做

思路

数组从中间切开，middleIndex为root，左面为左子树，右面为右子树，一直递归下去

代码：

python

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        if len(nums) == 0:
            return None
        
        if len(nums) == 1:
            return TreeNode(nums[0])
        
        if len(nums) == 2:
            root = TreeNode(nums[1])
            root.left = TreeNode(nums[0])
            return root

        middleIndex = len(nums) // 2
        root = TreeNode(nums[middleIndex])

        left = nums[0:middleIndex]
        right = nums[middleIndex+1: len(nums)]

        root.left = self.sortedArrayToBST(left)
        root.right = self.sortedArrayToBST(right)
        return root

代码随想录

思路：

相比自己做的代码，随想录用了指针来做的，我用的是数组

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

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

代码：

python

class Solution:
    def traversal(self, nums: List[int], left: int, right: int) -> TreeNode:
        if left > right:
            return None
        
        mid = left + (right - left) // 2
        root = TreeNode(nums[mid])
        root.left = self.traversal(nums, left, mid - 1)
        root.right = self.traversal(nums, mid + 1, right)
        return root
    
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        root = self.traversal(nums, 0, len(nums) - 1)
        return root

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

思路：

要理解什么是累加树：

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

从树中可以看出累加的顺序是右中左，所以我们需要反中序遍历这个二叉树，然后顺序累加就可以了

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def __init__(self):
        self.sum = 0
    def convertBST(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if root == None:
            return None
        
        self.convertBST(root.right)

        self.sum += root.val
        root.val = self.sum

        self.convertBST(root.left)

        return root