Day23 算法学习|二叉树08二叉树完结

Hola_error

已于 2023-06-30 20:07:10 修改

阅读量24

点赞数

文章标签：算法学习

于 2023-06-30 20:05:06 首次发布

本文链接：https://blog.csdn.net/m0_55811518/article/details/131479632

版权

题目 669. 修剪二叉搜索树

问题描述

给定一个二叉搜索树，同时给定最小边界L 和最大边界 R。通过修剪二叉搜索树，使得所有节点的值在[L, R]中 (R>=L) 。你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。
在这里插入图片描述

解题思路

如果节点为空（即遍历到叶子节点的子节点），直接返回空节点。
如果节点的值小于范围的最小值 low，说明该节点及其左子树都不在范围内，需要继续递归处理右子树，并返回右子树符合条件的头结点。
如果节点的值大于范围的最大值 high，说明该节点及其右子树都不在范围内，需要继续递归处理左子树，并返回左子树符合条件的头结点。
如果节点的值在范围内，说明该节点及其左右子树都在范围内，需要分别递归处理左右子树，并将修剪后的结果分别赋值给当前节点的左子树和右子树。

代码

递归

class Solution:
    def trimBST(self, root: TreeNode, low: int, high: int) -> TreeNode:
        if root is None:
            return None
        if root.val < low:
            # 寻找符合区间 [low, high] 的节点
            return self.trimBST(root.right, low, high)
        if root.val > high:
            # 寻找符合区间 [low, high] 的节点
            return self.trimBST(root.left, low, high)
        root.left = self.trimBST(root.left, low, high)  # root.left 接入符合条件的左孩子
        root.right = self.trimBST(root.right, low, high)  # root.right 接入符合条件的右孩子
        return root

***递归过程 ***
假设我们有以下二叉搜索树：

最终，修剪后的二叉搜索树如下：

迭代


class Solution:
    def trimBST(self, root: TreeNode, L: int, R: int) -> TreeNode:
        if not root:
            return None
        
        # 处理头结点，让root移动到[L, R] 范围内，注意是左闭右闭
        while root and (root.val < L or root.val > R):
            if root.val < L:
                root = root.right  # 小于L往右走
            else:
                root = root.left  # 大于R往左走
        
        cur = root
        
        # 此时root已经在[L, R] 范围内，处理左孩子元素小于L的情况
        while cur:
            while cur.left and cur.left.val < L:
                cur.left = cur.left.right
            cur = cur.left
        
        cur = root
        
        # 此时root已经在[L, R] 范围内，处理右孩子大于R的情况
        while cur:
            while cur.right and cur.right.val > R:
                cur.right = cur.right.left
            cur = cur.right
        
        return root

复杂度分析

时间复杂度O(n)/O(log n)
空间复杂度O(n)/O(log n)

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

问题描述

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

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

解题思路

在这里插入图片描述

这段代码的基本思想是二分法和递归。首先，我们找到输入数组的中间元素，并以此创建一个新的树节点，该节点作为二叉搜索树的根。然后，我们递归地对左半部分和右半部分的数组进行同样的操作，分别创建左子树和右子树。
递归的基准情况是当 left > right 时，此时说明数组中没有元素可以用来创建新的节点，所以返回 None。

代码

递归


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

递归模拟

[1, 2, 3, 4, 5, 6, 7]
初始化：我们首先找到中间元素，对于这个数组来说，中间元素是4。所以，我们创建一个新的节点，值为4，这个节点成为我们的根节点。

迭代

from collections import deque

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        if len(nums) == 0:
            return None
        
        root = TreeNode(0)  # 初始根节点
        nodeQue = deque()   # 放遍历的节点
        leftQue = deque()   # 保存左区间下标
        rightQue = deque()  # 保存右区间下标
        
        nodeQue.append(root)               # 根节点入队列
        leftQue.append(0)                  # 0为左区间下标初始位置
        rightQue.append(len(nums) - 1)     # len(nums) - 1为右区间下标初始位置

        while nodeQue:
            curNode = nodeQue.popleft()
            left = leftQue.popleft()
            right = rightQue.popleft()
            mid = left + (right - left) // 2

            curNode.val = nums[mid]  # 将mid对应的元素给中间节点

            if left <= mid - 1:  # 处理左区间
                curNode.left = TreeNode(0)
                nodeQue.append(curNode.left)
                leftQue.append(left)
                rightQue.append(mid - 1)

            if right >= mid + 1:  # 处理右区间
                curNode.right = TreeNode(0)
                nodeQue.append(curNode.right)
                leftQue.append(mid + 1)
                rightQue.append(right)

        return root

复杂度分析

时间复杂度O(n)
空间复杂度O(log(n))
我们使用了递归，递归深度在最坏的情况下为 n。但由于我们的输入数组是有序的，因此我们总是能够沿着数组的中间划分，使得树保持平衡，所以递归的深度是 log(n)。因此，空间复杂度是 O(log(n))。

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

问题描述

给出二叉搜索树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

提醒一下，二叉搜索树满足下列约束条件：

节点的左子树仅包含键小于节点键的节点。节点的右子树仅包含键大于节点键的节点。左右子树也必须是二叉搜索树。
在这里插入图片描述

解题思路

任一节点的左子树中的节点值都小于该节点的值，而右子树中的节点值都大于该节点的值
因此，我们可以通过反向中序遍历（即先遍历右子树，再遍历根节点，最后遍历左子树）得到从大到小的节点值。
在遍历过程中，我们利用一个全局变量 cur 来累计已遍历的节点值，这就保证了当我们遍历到某个节点时，cur 中存储的是所有比该节点值大的节点值之和。然后，我们只需要将 cur 的值加到当前节点的值上，即可完成题目的要求。

代码

递归1

class Solution:
    def convertBST(self, root: TreeNode) -> TreeNode:
        self.pre = 0  # 记录前一个节点的数值
        self.traversal(root)
        return root
    def traversal(self, cur):
        if cur is None:
            return        
        self.traversal(cur.right)
        cur.val += self.pre
        self.pre = cur.val
        self.traversal(cur.left)

递归2

class Solution:
    def __init__(self):
        self.cur = 0  # 全局变量，用来累积已经遍历过的节点的值
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if  root:
            self.convertBST(root.right)  # 先遍历右子树

            # 遍历到当前节点，更新节点的值和累积值
            self.cur += root.val
            root.val = self.cur

             self.convertBST(root.left)  # 最后遍历左子树

        return root

递归模拟

在这里插入图片描述

迭代法（版本二）


class Solution:
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root: return root
        stack = []
        result = []
        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

复杂度分析

时间复杂度O(n)
空间复杂度O(h)

Hola_error

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day23 算法学习|二叉树08二叉树完结

给定一个二叉搜索树，同时给定最小边界L 和最大边界 R。通过修剪二叉搜索树，使得所有节点的值在[L, R]中 (R>=L)。你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。
复制链接

扫一扫