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

669. 修剪二叉搜索树 

题目链接:修剪二叉搜索树

解法:

递归:递归函数需要有返回值,更方便,可以通过递归函数的返回值来移除节点。

如果root(当前节点)的元素小于low的数值,那么应该递归右子树,并返回右子树符合条件的头结点。如果root(当前节点)的元素大于high的,那么应该递归左子树,并返回左子树符合条件的头结点。接下来要将下一层处理完左子树的结果赋给root->left,处理完右子树的结果赋给root->right。

迭代法:不需要用到栈和队列,因为是有序的。在剪枝的时候,可以分为三步:

  • 将root移动到[L, R] 范围内,注意是左闭右闭区间
  • 剪枝左子树
  • 剪枝右子树

迭代法比较麻烦,自己写还真写不出来。

边界条件:

时间复杂度:

空间复杂度:

# 递归法
# 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):
        """
        :type root: TreeNode
        :type low: int
        :type high: int
        :rtype: TreeNode
        """
        if not root:
            return None

        if root.val > high:
            return self.trimBST(root.left, low, high)
        elif root.val < low:
            return self.trimBST(root.right, low, high)
        else:
            root.left = self.trimBST(root.left, low, high)
            root.right = self.trimBST(root.right, low, high) 
            return root
# 迭代法
# 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):
        """
        :type root: TreeNode
        :type low: int
        :type high: int
        :rtype: TreeNode
        """
        if not root:
            return root
        
        # 把root移动到值在区间内
        while root and (root.val < low or root.val > high):
            if root.val < low:
                root = root.right
            if root.val > high:
                root = root.left
        # 对左子树减枝
        cur = root
        while cur:
            # 不断减枝,直到值在区间内
            while cur.left and cur.left.val < low:
                cur.left = cur.left.right
            # 更新cur节点,继续减枝,直到空节点
            cur = cur.left
        # 对右子树减枝
        cur = root
        while cur:
            while cur.right and cur.right.val > high:
                cur.right = cur.right.left
            cur = cur.right
        return root

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

题目链接:将有序数组转化为二叉树搜索树

解法:

一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

这个题本质就是寻找分割点,分割点作为当前节点,然后递归左区间和右区间。分割点就是数组中间位置的节点。如果数组的长度是偶数,那么中间节点取左或右的都行,构造的二叉树都满足条件。

递归法:实现细节上,如果使用left和right的来原地取数,可以不用重新定义左右区间数组,而是用下标来操作原数组。但是要注意:int mid = left + ((right - left) / 2),要这么写,防止因为left和right过大,导致越界。我自己实现的方式是不用left和right,也是原地取数。

迭代法:迭代法非常麻烦,不直观,不适合。

边界条件:无

时间复杂度:

空间复杂度:

# 递归法
# 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 not nums:
            return None
        if len(nums) == 1:
            return TreeNode(nums[0])
        mid = len(nums) // 2
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:])
        return root

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

题目链接:把二叉搜索树转换为累加树

解法:

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

需要一个pre指针记录当前遍历节点cur的前一个节点,这样才方便做累加。要右中左来遍历二叉树, 中节点的处理逻辑就是让cur的数值加上前一个节点的数值,并且更新pre指针。

递归法和迭代法,都是用中序遍历的模版,然后改为右中左来处理即可。

边界条件:

时间复杂度:

空间复杂度:

# 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 convertBST(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        # pre指针记录上一步的值
        self.pre = 0
        self.traversal(root)
        return root

    def traversal(self, root):
        # 直接修改node的值,不用返回
        if not root:
            return
        # 按右中左的顺序进行处理
        self.traversal(root.right)
        root.val += self.pre
        self.pre = root.val
        self.traversal(root.left)
# 迭代法
# 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 convertBST(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return None
        stack = []
        cur = root
        pre = 0
        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.right
            else:
                cur = stack.pop()
                cur.val += pre
                pre = cur.val
                cur = cur.left
        return root
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值