python 刷leetcode题目（26）

二叉搜索树中的搜索

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

class Solution(object):
    def searchBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        if root is None:
            return None
        if root.val == val:
            return root   
        if root.val > val:
            return self.searchBST(root.left, val)
        else:
            return self.searchBST(root.right, val)
        

二叉树的插入操作：

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

class Solution(object):
    def insertIntoBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        if root is None:
            root = TreeNode(val)
        else:
            if val < root.val:
                root.left = self.insertIntoBST(root.left, val)       
            else:
                root.right = self.insertIntoBST(root.right, val)
        return root

        

二叉树的删除操作：

删除要比我们前面提到过的两种操作复杂许多。有许多不同的删除节点的方法，这篇文章中，我们只讨论一种使整体操作变化最小的方法。我们的方案是用一个合适的子节点来替换要删除的目标节点。根据其子节点的个数，我们需考虑以下三种情况：

1. 如果目标节点 没有子节点，我们可以直接移除该目标节点。
2. 如果目标节 只有一个子节点，我们可以用其子节点作为替换。
3. 如果目标节点 有两个子节点，我们需要用其中序后继节点或者前驱节点来替换，再删除该目标节点。

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


class Solution(object):
    
    def findmin(self, root):
        if root.left:
            return self.findmin(root.left)
        else:
            return root
    
    def deleteNode(self, root, key):
        """
        :type root: TreeNode
        :type key: int
        :rtype: TreeNode
        """
        if root:
            if key < root.val:
                root.left =  self.deleteNode(root.left, key)
            elif key > root.val:
                root.right =  self.deleteNode(root.right, key)
            elif root.left and root.right:   #### 删除要区分左右孩子是否为空的情况
                temp = self.findmin(root.right)  ### 找到后继节点
                root.val = temp.val
                root.right = self.deleteNode(root.right, root.val)  #### 实际删除的是这个后继节点，然后用其他值来代替这个位置
            else:
                if root.left is None:
                    root = root.right
                elif root.right is None:
                    root = root.left
        return root

二叉搜索树迭代器

实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器。

调用 next() 将返回二叉搜索树中的下一个最小的数。

注意: next() 和hasNext() 操作的时间复杂度是O(1)，并使用 O(h) 内存，其中 h 是树的高度。

代码如下：

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

class BSTIterator(object):
    def __init__(self, root):
        """
        :type root: TreeNode
        """
        self.cur = root
        self.stack = []      
        
    def hasNext(self):
        """
        :rtype: bool
        """
        return self.stack or self.cur      

    def next(self):
        """
        :rtype: int
        """
        while self.cur:
            self.stack.append(self.cur)
            self.cur = self.cur.left
        
        self.cur = self.stack.pop()
        node = self.cur
        self.cur = self.cur.right
        
        return node.val
                      
# Your BSTIterator will be called like this:
# i, v = BSTIterator(root), []
# while i.hasNext(): v.append(i.next())