第七章：二叉搜索树

定义：

二叉排序树又叫二叉查找树或者二叉搜索树，它首先是一个二叉树，而且必须满足下面的条件：

1）若左子树不空，则左子树上所有结点的值均小于它的根节点的值；

2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值

3）左、右子树也分别为二叉排序树

处处的局部顺序性，全局的单调性。

中序遍历的歧义性：

查找

插入

删除

双分支的情况：
首先找到被删除节点的直接后继（中序遍历的下一个，也就是不小于该节点的最小的节点）。

查找直接后继算法：
如果当前节点存在右子树，则在右子树沿着左分支不断下行，直至不能下行。

平衡与等价

中位数越早被插入，树的高度倾向于越低。

调整原则：
局部性：限于常数规模的调整
调整次数限于log(n)

平衡二叉树

AVL树： 重平衡

AVL树：插入

p的左孩子变为g的右孩子，局部子树的根由g转为p：

AVL树：删除

AVL树：重构

Coding

Serialize and Deserialize BST

class Codec:

    def serialize(self, root):
        """Encodes a tree to a single string.

        :type root: TreeNode
        :rtype: str
        """
        res=[]
        def preorder(root):
            if not root:
                return
            res.append(root.val)
            preorder(root.left)
            preorder(root.right)

        preorder(root)
        return " ".join(map(str,res))


    def deserialize(self, data):
        """Decodes your encoded data to tree.

        :type data: str
        :rtype: TreeNode
        """
        data=list(map(int,data.split()))

        def build(vals,left,right):
            if vals and left<vals[0]<right:
                val=vals.pop(0)
                node=TreeNode(val)
                node.left=build(vals,left,val)
                node.right=build(vals,val,right)
                return node
        return build(data,-sys.maxsize,sys.maxsize)

Validate BST

class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """

        def validate(root,left,right):
            if not root:
                return True
            if root.val<=left or root.val>=right:
                return False
            return validate(root.left,left,root.val) and validate(root.right,root.val,right)
        return validate(root,-sys.maxsize,sys.maxsize)   

Insert a node in BST

class Solution:
    """
    @param: root: The root of the binary search tree.
    @param: node: insert this node into the binary search tree
    @return: The root of the new binary search tree.
    """
    def insertNode(self, root, node):
        # write your code here
        if not root:
            return node
        if not node:
            return root

        def insert(root,node):
            if node.val<root.val:
                if root.left is None:
                    root.left=node
                    return 
                self.insertNode(root.left,node)
            else:
                if root.right is None:
                    root.right=node
                    return
                self.insertNode(root.right,node)

        insert(root,node)
        return root

Search Range in BST

class Solution:
    """
    @param root: param root: The root of the binary search tree
    @param k1: An integer
    @param k2: An integer
    @return: return: Return all keys that k1<=key<=k2 in ascending order
    """
    def searchRange(self, root, k1, k2):
        # write your code here
        res=[]

        def search(root,k1,k2):
            if not root:
                return
            if k1>root.val:
                search(root.right,k1,k2)

            elif k2<root.val:
                search(root.left,k1,k2)

            else:# k1<=root.val<=k2
                res.append(root.val)

                search(root.right,k1,k2)
                search(root.left,k1,k2)

        search(root,k1,k2)
        return res

Remove node in BST

Count of Smaller Numbers After Self

---

二叉搜索树-python实现
算法导论程序29–二叉搜索树的插入和删除（Python）