leetcode 二叉树搜索 II

leetcode做题记录

700. 二叉搜索树中的搜索

class Solution(object):
    def searchBST(self, root, val):
        if not root:return None
        if root.val<val:return self.searchBST(root.right,val)
        elif root.val>val:return self.searchBST(root.left,val)
        elif root.val==val:return root

98. 验证二叉搜索树

设定一个max_参数记录前一个节点的值，递归中序遍历，检查前一个节点的值是否小于当前节点。

class Solution(object):
    def isValidBST(self, root):
        self.max_=float('-inf')
        return self.isvalid(root)
    def isvalid(self,root):
        if not root:return True
        left=self.isvalid(root.left)
        if self.max_<root.val:self.max_=root.val
        else:return False
        right=self.isvalid(root.right)
        return left and right

530. 二叉搜索树的最小绝对差

二叉树搜索树中序遍历的有序数组，再计算任意两个节点最小差值

class Solution(object):
    def getMinimumDifference(self, root):
        self.res=float('inf')
        self.tra=[]
        self.travel(root)
        for i in range(1,len(self.tra)):
            self.res=min(self.res,abs(self.tra[i]-self.tra[i-1]))
        return self.res
    def travel(self,root):
        if not root:return
        self.travel(root.left)
        self.tra.append(root.val)
        self.travel(root.right)

501. 二叉搜索树中的众数

设置pre节点，比较当前节点和pre节点，并记录count；max_count改变时，res列表也要重置

class Solution(object):
    def __init__(self):
        self.pre=TreeNode()
        self.count=0
        self.max_=0
        self.res=[]
    def findMode(self, root):
        if not root:return None
        self.findMode(root.left)
        if not self.pre:
            self.count=1
        elif self.pre.val==root.val:
            self.count+=1
        else:self.count=1
        self.pre=root
        if self.count==self.max_:
            self.res.append(root.val)
        if self.count>self.max_:
            self.max_=self.count
            self.res=[root.val]
        self.findMode(root.right)
        return self.res

236. 二叉树的最近公共祖先

后序遍历，如果找到一个节点，发现左子树出现结点p，右子树出现节点q，或者 左子树出现结点q，右子树出现节点p，那么该节点就是节点p和q的最近公共祖先；或者节点本身p(q)，它拥有一个子孙节点q(p)。

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        if root==p or root==q or not root:return root
        left=self.lowestCommonAncestor(root.left,p,q)
        right=self.lowestCommonAncestor(root.right,p,q)
        if left and right:return root

        if not left and right:return right
        elif left and not right:return left
        else:return None

235. 二叉搜索树的最近公共祖先

从上向下去递归遍历，第一次遇到 cur节点是数值在[p, q]区间中，那么cur就是 p和q的最近公共祖先。

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        if root.val>p.val and root.val>q.val:
            left=self.lowestCommonAncestor(root.left,p,q)
            if left:return left
        elif root.val<p.val and root.val<q.val:
            right=self.lowestCommonAncestor(root.right,p,q)
            if right:return right
        else:return root

701. 二叉搜索树中的插入操作

class Solution(object):
    def insertIntoBST(self, root, val):
        if not root:
            node=TreeNode(val)
            return node
        if root.val<val:
            root.right=self.insertIntoBST(root.right,val)
        if root.val>val:
            root.left=self.insertIntoBST(root.left,val)
        return root

450. 删除二叉搜索树中的节点

第一种情况：没找到删除的节点，遍历到空节点直接返回了找到删除的节点

第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点

第三种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点

第四种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点

第五种情况：左右孩子节点都不为空，则将删除节点的左子树头结点（左孩子）放到删除节点的右子树的最左面节点的左孩子上，返回删除节点右孩子为新的根节点。

class Solution(object):
    def deleteNode(self, root, key):
        if not root:return None
        if root.val>key:
            root.left=self.deleteNode(root.left,key)
        elif root.val<key:
            root.right=self.deleteNode(root.right,key)
        else:
            if not root.left :return root.right
            elif not root.right:return root.left
            else:
                #找右子树最左节点
                cur=root.right
                while cur.left:
                    cur=cur.left
                cur.left=root.left
                root=root.right
        return root

669. 修剪二叉搜索树

class Solution(object):
    def trimBST(self, root, low, high):
        if not root:return None
        if root.val>high:
            left=self.trimBST(root.left,low,high)
            return left
        if root.val<low:
            right=self.trimBST(root.right,low,high)
            return right
        root.left=self.trimBST(root.left,low,high)
        root.right=self.trimBST(root.right,low,high)
        return root

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

右中左遍历，设置pre指针

class Solution(object):
    def convertBST(self, root):
        self.pre=TreeNode()
        self.travel(root)
        return root
    def travel(self,root):
        if not root:return 
        self.travel(root.right)
        root.val+=self.pre.val
        self.pre=root
        self.travel(root.left)

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

根据数组构造一棵二叉树，本质就是寻找分割点，分割点作为当前节点，然后递归左区间和右区间。

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

129. 求根节点到叶节点数字之和

class Solution(object):
    def sumNumbers(self, root):
        path=''
        res=[]
        result=self.travel(root,path+str(root.val),res)
        sum_=0
        for i in range(len(result)):
            result[i]=int(result[i])
            sum_+=result[i]
        return sum_
    def travel(self,root,path,res):
        if not root.left and not root.right:
            res.append(path)
        if root.left:
            self.travel(root.left,path+str(root.left.val),res)
        if root.right:
            self.travel(root.right,path+str(root.right.val),res)
        return res

1382. 将二叉搜索树变平衡

可以中序遍历把二叉树转变为有序数组，然后在根据有序数组构造平衡二叉搜索树。

class Solution(object):
    def balanceBST(self, root):
        self.res=[]
        self.pretravel(root)
        root=self.buildtree(self.res,0,len(self.res)-1)
        return root
    def buildtree(self,nums,left,right):
        if left>right:return None
        mid=left+((right-left)/2)
        root=TreeNode(nums[mid])
        root.left=self.buildtree(nums,left,mid-1)
        root.right=self.buildtree(nums,mid+1,right)
        return root
    def pretravel(self,root):
        if not root:return None
        self.pretravel(root.left)
        self.res.append(root.val)
        self.pretravel(root.right)