5.10 力扣 二叉搜索树 专题 671在议（没有利用节点值小于等于子节点的条件） 450 删除二叉搜索树中结点（利用前序，后继）

173 二叉搜索树迭代器：


迭代器是使程序员能够遍历容器的对象。
hasNext()：若栈中还有元素，则返回 true，反之返回 false。所以这是一个 O(1)的操作
不符合题目要求：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class BSTIterator:

    def __init__(self, root: TreeNode):
        self.res=[]
        self.root=root
        node=self.root
        stack=[]
        while stack or node:
            while node:
                stack.append(node)
                node=node.left
            node=stack.pop()
            self.res.append(node.val)
            node=node.right
    def next(self) -> int:
        """
        @return the next smallest number
        """
        return self.res.pop(0)

    def hasNext(self) -> bool:
        """
        @return whether we have a next smallest number
        """
        return len(self.res)>=1
# Your BSTIterator object will be instantiated and called as such:
# obj = BSTIterator(root)
# param_1 = obj.next()
# param_2 = obj.hasNext()

采用迭代的方式来模拟中序遍历，而不是采用递归的方法；这样做的过程中，我们能够轻松的实现这两个函数的调用，而不是用其他额外的空间。
初始化一个空栈 S，用于模拟二叉搜索树的中序遍历。中序遍历我们采用与之前相同的方法，只是我们现在使用的是自己的栈而不是系统的堆栈。由于我们使用自定义的数据结构，因此可以随时暂停和恢复递归。
空间复杂度：O(h)，使用了一个栈来模拟递归

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

class BSTIterator:

    def __init__(self, root: TreeNode):
        self.current = root
        self.st = []

        
    def next(self) -> int:
        """
        @return the next smallest number
        """       
        while self.current or self.st:
            while self.current:
                self.st.append(self.current)
                self.current = self.current.left
            self.current = self.st.pop()
            node = self.current
            self.current = self.current.right
            return node.val

    def hasNext(self) -> bool:
        """
        @return whether we have a next smallest number
        """
        if self.st or self.current:
            return True
        return False
# Your BSTIterator object will be instantiated and called as such:
# obj = BSTIterator(root)
# param_1 = obj.next()
# param_2 = obj.hasNext()

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

class Solution:
    def getMinimumDifference(self, root: TreeNode) -> int:
        minmum=float('inf')
        stack=[]
        pre=float('-inf')
        while stack or root:
            while root:
                stack.append(root)
                root=root.left
            root=stack.pop()
            minmum=min(minmum,abs(root.val-pre))
            pre=root.val
            root=root.right
        return minmum

532. 数组中的K-diff数对

哈希表对数据去重：

class Solution:
    def findPairs(self, nums: List[int], k: int) -> int:
        if not nums or k<0:
            return 0
        hash={}
        count=0
        for i in range(len(nums)):
            if nums[i] not in hash:
                hash[nums[i]]=1
            else:
                hash[nums[i]]+=1
        if k==0:
            for i in hash:
                if hash[i]>1:
                    count+=1
        elif k>0:
            for i in hash:
                if i+k in hash:
                    count+=1
        return count 

230 二叉搜索树中第K小元素

class Solution:
    def kthSmallest(self, root: TreeNode, k: int) -> int:
        if not root:
            return 
        stack=[]
        while stack or root:
            while root:
                stack.append(root)
                root=root.left
            root=stack.pop()
            k-=1
            if k==0:
                return root.val
            root=root.right

671. 二叉树中第二小的节点

时间复杂度 空间复杂度均为O（n）
没有利用

class Solution:
    def findSecondMinimumValue(self, root: TreeNode) -> int:
        def dfs(root):
            if not root:
                return []
            return [root.val]+dfs(root.left)+dfs(root.right)
        res=dfs(root)      
        res=list(set(res))
        res.sort()
        return res[1] if len(res)>=2 else -1

672. 两数之和 IV - 输入 BST

中序遍历
递归：

class Solution:
    def findTarget(self, root: TreeNode, k: int) -> bool:
        self.target=k
        self.ans=False
        self.hash=set()
        def dfs(root):
            if not root:
                return False
            dfs(root.left)
            #self.ans剪枝
            if self.target-root.val in self.hash and not self.ans:
                self.ans=True 
                return 
            self.hash.add(root.val)
            dfs(root.right)
        dfs(root)
        return self.ans

迭代：

class Solution:
    def findTarget(self, root: TreeNode, k: int) -> bool:
        if not root:
            return False
        stack=[]
        visit=set()
        while stack or root:
            while root:
                stack.append(root)
                root=root.left
            root=stack.pop()
            if k-root.val in visit:
                return True
            visit.add(root.val)
            root=root.right
        return False

673. 两数之和 II - 输入有序数组

双指针法：

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        i,j=0,len(numbers)-1
        res=[]
        while i<j:
            if numbers[i]+numbers[j]==target:
                res.extend([i+1,j+1])
                return res
            elif numbers[i]+numbers[j]<target:
                i+=1
            elif numbers[i]+numbers[j]>target:
                j-=1
       return [-1,-1]

二叉搜索树中复杂度为对数时间的操作：查找 插入 删除
450 删除二叉搜索树中的节点


（一） 按情况分类解法 算法思想
1 检索要删除的节点p，并在检索的过程中记录其父结点par。
2 删除节点
假设已经确定应该删除节点p,它是其父节点par的左子节点。（为右子节点的情况类似）
（1）如果p为叶子节点，直接删除。即令par的左子节点为空。
（2）如果p.left为空树，这事只需把p的右子树改为其父结点par的左子树。
（3）p有左子树，这时先找到p的左子树的最右节点，设为r,显然它没有右子树。用p的左子节点代替par的左子节点，并将p的右子树作为r的右子树。

# 该方法是将删除节点的右子树加到删除节点的左子树的后面
class Solution:
    def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
        p=root
        pre=None
        while p:
            if key<p.val:
                pre=p
                p=p.left
            elif key>p.val:
                pre=p
                p=p.right
            else:
                #p是叶子结点
                if not p.left and not p.right:
                    #p是根节点，且无子树
                    if pre==None:
                        root=None
                    else:
                        #p是pre的左叶子节点
                        if key<pre.val:
                            pre.left=None
                        #p是pre的右叶子结点
                        else:
                            pre.right=None
                elif not p.left:
                    #如果只有右子树，则直接将p的右子树接到pre上
                    if pre==None:
                        root=p.right
                    else:
                        if key<pre.val:
                            pre.left=p.right
                        else:
                            pre.right=p.right
                else:
                    #存在左子树
                    #找到p的左子树中最大的点，即递增序列中p前面的点，即比p小的值中的最大值，即p的前序节点
                    r=p.left
                    while r.right:
                        r=r.right
                    #说明p是根节点，将p的左子树作为新的根节点，右子树加到根节点在递增序列中的前一个点的右边
                    if pre==None:
                        r.right=p.right
                        root=p.left
                    else:
                        #p不是根节点，且位于父节点的左侧
                        if key<pre.val:
                            pre.left=p.left
                            r.right=p.right
                        else:
                        #p不是根节点，且位于父节点的右侧
                            pre.right=p.left
                            r.right=p.right
                #找到这样的p
                return root
        #遍历完还没找到，返回原来root
        return root

二叉搜索树的前驱节点：
对于前驱，节点要有左子树；对于后继，节点要有右子树。
代表的是中序遍历序列的前一个节点。即比当前节点小的最大节点，简称前驱节点。先取当前节点的左节点，然后取该节点的右节点，直到右节点为空，则最后指向的节点为前驱节点。
如果不存在左子树，则该节点的前驱节点在节点之上面，不方便迭代向下删除

#当存在左子树时
def predecessor(root):
    root = root.left
    while root.right:
        root = root.right
    return root

二叉搜索树的后继节点：
中序遍历序列的下一个节点。即比当前节点大的最小节点，简称后继节点。 先取当前节点的右节点，然后一直取该节点的左节点，直到左节点为空，则最后指向的节点为后继节点。
该后继节点位于右子树中较低的位置。然后可以从后继节点的位置递归向下操作以删除后继节点。
如果该节点不存在右子树时，该方法不成立，因为此时节点的后继节点在其上面

##当存在右子树时
def successor(root):
    root = root.right
    while root.left:
        root = root.left
    return root

（二）递归解法：
不是删除该节点，而是用其后继或前驱节点值替换，然后递归删除其后继或前驱节点
速度比分情况讨论慢
算法思想：
1.当Key大于当前节点值，则说明需要删除的节点位于当前节点右子树
2.当Key小于当前节点值，则说明需要删除的节点位于当前节点左子树
3。当key等于当前节点值
1.若当前节点为叶子结点，则直接赋值None
2.若当前节点存在右子树，则按照二叉搜素树中序性质，其后继节点在右子树中，用后继节点值替换当前节点值，然后递归删除后继节点
3.若当前节点不存在右子树单存在左子树，则后继节点在当前节点上面或者不存在，前序节点在左子树中，则可以用前序节点值替换，递归删除前序节点值

class Solution:
    #后继节点
    def successor(self,root):
        root=root.right
        while root.left:
            root=root.left
        return root.val
    #前驱节点
    def predecessor(self,root):
        root=root.left
        while root.right:
            root=root.right
        return root.val
    def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
        if not root:
            return 
        #  要删除的节点在右子树
        if key>root.val:
            root.right=self.deleteNode(root.right,key)
        # 要删除的节点在左子树
        elif key<root.val:
            root.left=self.deleteNode(root.left,key)
        # 找到需要删除的节点
        else:
            #叶子结点直接赋值None
            if not root.left and not root.right:
                root=None
            # 存在右子树（左子树存不存在都可以），用后继节点值替换，然后递归向下删除右子树中的后继节点
            elif root.right:
                root.val=self.successor(root)
                root.right=self.deleteNode(root.right,root.val)
            # 只存在左子树，用前驱节点值替换，然后删除左子树中的前驱节点
            # 要删除的节点不是叶子节点，且没有右节点但是有左节点。这意味着它的后继节点在它的上面，但是我们并不想返回。我们可以使用它的前驱节点进行替代，然后再递归的向下删除前驱节点。
            elif root.left:
                root.val=self.predecessor(root)
                root.left=self.deleteNode(root.left,root.val)
        return root

700. 二叉搜索树中的搜索


迭代比递归空间复杂度低
迭代：

class Solution:
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
    	p=root
        if not p:
            return 
        while p:
            if p.val<val:
                p=p.right
            elif p.val>val:
                p=p.left
            else:
                return p
        return None

递归：

class Solution:
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
        if not root:
            return 
        if root.val<val:
            return self.searchBST(root.right,val)
        elif root.val>val:
            return self.searchBST(root.left,val)
        else:
            return root

701 二叉搜索树的插入操作：

迭代：
1如果二叉搜索树为空树，用val构造二叉树节点作为根节点并返回。
2否则，搜索新结点的插入位置，沿子结点关系向下：
遇到应该走向左子树而左子树为空，或者应该走向右子树而右子树为空时，就是找到了新字典项的插入位置，构造新结点并完成实际插入。
之后，返回根节点。

class Solution:
    def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
        p=TreeNode(val)
        if not root:
            return p
        node=root
        #插入到右子树
        while node:
            if node.val<val:
                if node.right:
                    node=node.right
                else:
                    node.right=p
                    return root
            else:
                if node.left:
                    node=node.left
                else:
                    node.left=p
                    return root

递归：

class Solution:
    def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
        p=TreeNode(val)
        if not root:
            return p
        #插入到右子树
        if root.val<val:
        	root.right=self.insertIntoBST(root.right,val)
        else:
            root.left=self.insertIntoBST(root.left,val)
        return root

1305 两棵二叉搜索树中所有元素

class Solution:
    def getAllElements(self, root1: TreeNode, root2: TreeNode) -> List[int]:
        def dfs(root):
            if not root:
                return []
            return dfs(root.left)+[root.val]+dfs(root.right)
        res1=dfs(root1)
        res2=dfs(root2)
        n1,n2=len(res1),len(res2)
        res=[]
        i,j=0,0
        while i<n1 and j<n2:
            if res1[i]<res2[j]:
                res.append(res1[i])
                i+=1
            else:
                res.append(res2[j])
                j+=1
        if j==n2:
            res.extend(res1[i:]) 
        else :
            res.extend(res2[j:])
        return res

面试题33 二叉搜索树的后序遍历序列

后序遍历 根节点在最后
在数组中从后往前第一个小于根节点的数值，前面的都是左子树，后面的都是右子树，依次递归判断，一旦某部分不符合条件，则说明不是二叉搜索树
自己的写法：

class Solution:
    def verifyPostorder(self, postorder):

        if len(postorder)<=1:
            return True
        root=postorder[-1]
        index=-1
        #找到左右子树分割点index
        for i in range(len(postorder)-2,-1,-1):
            if postorder[i]<root:
                index=i
                break
        flag1,flag2=True,True
        #判断左子树数据是否都小于根节点
        for pos in postorder[:index+1]:
            if pos>root:
                flag1=False
         #判断右子树数据是否都大于根节点
        for pos in postorder[index+1:-1]:
            if pos<root:
                flag2=False
        return flag1 and flag2 and self.verifyPostorder(postorder[:index+1]) and self.verifyPostorder(postorder[index+1:-1])

题解写法：

class Solution:
    def verifyPostorder(self, postorder: [int]) -> bool:
        def recur(i, j):
            if i >= j: return True
            p = i
            while postorder[p] < postorder[j]: 
            	p += 1
            #找到左右子树分割点
            # 从左到右 第一个大于根节点 的节点
            m = p
            while postorder[p] > postorder[j]: 
            	p += 1
            #每次取出一个根节点
            return p == j and recur(i, m - 1) and recur(m, j - 1)
        return recur(0, len(postorder) - 1)