Day23 今天做了三个题 ● 669. 修剪二叉搜索树 ● 108.将有序数组转换为二叉搜索树 ● 538.把二叉搜索树转换为累加树

先对二叉树做一个总结：

满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。深度为k，有2^k-1个节点的二叉树。

完全二叉树：除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（h从1开始），则该层包含 1~ 2^(h-1) 个节点。   （完全二叉树底层必须是从左到右连续的，且次底层是满的。）

二叉搜索树：二叉搜索树是一个有序树。

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉排序树

平衡二叉搜索树:

又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

二叉树的储存方式 ：二叉树可以链式存储，也可以顺序存储。

二叉树主要有两种遍历方式：

1. 深度优先遍历：先往深走，遇到叶子节点再往回走。
2. 广度优先遍历：一层一层的去遍历。

• 深度优先遍历
  • 前序遍历（递归法，迭代法）
  • 中序遍历（递归法，迭代法）
  • 后序遍历（递归法，迭代法）
• 广度优先遍历
  • 层次遍历（迭代法）

定义一个二叉树

class TreeNode:
    def __init__(self, val, left = None, right = None):
        self.val = val
        self.left = left
        self.right = right

669. 修剪二叉搜索树

1.
class Solution:
    def traversal(self,node,low,high):
        if not node:
            return None
        if node.val<low:
            right=self.traversal(node.right,low,high)
            return right
        if node.val>high:
            left=self.traversal(node.left,low,high)
            return left
        node.left=self.traversal(node.left,low,high)
        node.right=self.traversal(node.right,low,high)
        return node
    def trimBST(self, root, low, high):
        """
        :type root: TreeNode
        :type low: int
        :type high: int
        :rtype: TreeNode
        """
        return self.traversal(root,low,high)
2.
class Solution:
    def trimBST(self, root: Optional[TreeNode], low: int, high: int) -> Optional[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

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

class Solution:
    def traversal(self,nums,left,right):
        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):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        root=self.traversal(nums,0,len(nums)-1)
        return root

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

class Solution:
    def __init__(self):
        self.pre=0
    def convertBST(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        self.traversal(root)
        return root

    def traversal(self,node):
        if not node:
            return 0
        self.convertBST(node.right)
        node.val += self.pre
        self.pre=node.val
        self.convertBST(node.left)

#再贴个迭代
class Solution:
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root
        cur=root
        pre=0
        res=[]
        stack=[]
        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