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

删除比较麻烦：

1.如果z没有孩子结点，那么只是简单地将它删除，并修改它的父结点。用NIL作为孩子来替换z。

2.如果z只有一个孩子，那么将这个孩子提升到树中z的位置上，并修改z的父结点，用z的孩子来替换z。

3.如果z有两个孩子，那么找z的后继y（一定在z的右子树中）并让y占据树中z的位置，z的原来右子树部分成为y的新右子树，并且z的左子树成为y的新左子树。如果y位于z的右子树中，但不是z的右孩子，那么，先用y的右孩子替换y，然后再用y替换z。

class Node:
    def __init__(self,key,right,left,p):
        self.key=key
        self.right=right
        self.left=left
        self.p=p

class tree:
    def __init__(self,root):
        self.root=root
    def tree_insert(self,z):
        y=None
        x=self.root
        while x!=None:
            y=x
            if z.key<x.key:
                x=x.left
            else:
                x=x.right
        z.p=y
        if y==None:
            self.root=z
        elif z.key<y.key:
            y.left=z
        else:
            y.right=z
    def inorder_tree_walk(self,x):
        if x!=None:
            self.inorder_tree_walk(x.left)
            print(x.key)
            self.inorder_tree_walk(x.right)
    def tree_search(self,x,k):
        if x==None or k==x.key:
            return x
        if k < x.key:
            return self.tree_search(x.left,k)
        else: return self.tree_search(x.right,k)

    def iterative_tree_search(self,x,k):
        while x!=None and k!=x.key:
            if k<x.key:
                x=x.left
            else:
                x=x.right
        return x
    def tree_minimum(self,x):
        while x.left!=None:
            x=x.left
        return x
    def tree_maximum(self,x):
        while x.right!=None:
            x=x.right
        return x
    def tree_successor(self,x):
        if x.right!=None:
            return self.tree_minimum(x.right)
        y=x.p
        while y!=None and x==y.right:
            x=y
            y=y.p
        return y
    def tree_delete(self,z):
        if z.left==None:
            self.transplant(z,z.right)
        elif z.right==None:
            self.transplant(z,z.left)
        else:
            y=self.tree_minimum(z.right)
            if y.p!=z:
                self.transplant(y,y.right)
                y.right=z.right
                y.right.p=y
            self.transplant(z,y)
            y.left=z.left
            y.left.p=y
    def transplant(self,u,v):
        if u.p==None:
            self.root=v
        elif u==u.p.left:
            u.p.left=v
        else:
            u.p.right=v
        if v!=None:
            v.p=u.p
        

运行结果：

>>> root=Node(15,None,None,None)
>>> t=tree(root)
>>> T=[6,18,3,7,17,20,2,4,13,9]

>>> for i in T:
	r=Node(i,None,None,None)
	t.tree_insert(r)

	
>>> t.inorder_tree_walk(t.root)
2
3
4
6
7
9
13
15
17
18
20

>>> t.tree_delete(t.tree_search(t.root,7))
>>> t.inorder_tree_walk(t.root)
2
3
4
6
9
13
15
17
18
20