算法导论 python代码 第十二章

# author Ttssxuan
# chapter 12
# the binary search tree

class Node:
    '''
    the node of the binary tree

    Properties:
        p - the parent of the current node
        left - the left child of the current node
        right - the right child of the current node
        value - the value of this node
    '''
    def __init__(self):
        self.p = None
        self.left = None
        self.right = None
        self.value =  None
    def __init__(self, other):
        self.p = other.p
        self.left = other.left
        self.right = other.right
        self.value = other.value
    def __str__(self):
        return str(self.value)

def inorder_tree_walk(x):
    '''
    scan all keys by inorder tree walk method

    Parameters:
        x - the root of the binary search tree
    Returns:
        none
    '''
    if x != None:
        inorder_tree_walk(x.left)
        print(x + " ")
        inorder_tree_walk(x.right)

def interative_inorder_tree_wal(x):
    '''
    12.1.3
    scan all keys by inorder tree walk method with nonrecursive

    Parameters:
        x - the root of the binary search tree
    Returns:
        none
    '''
    done = False
    cur = Node(x)
    stack = []
    while(done):
        if cur != None:
            stack.append(cur)
            cur = cur.left
        else:
            if len(stack) > 0:
                cur = stack.pop()
                print(cur + " ")
                cur = cur.right
            else:
                done = True

def preorder_tree_walk(x):
    '''
    12.1.4
    scan all keys by preorder tree walk method

    Parameters:
        x - the root of the binary search tree
    Returns:
        none
    '''
    if x != None:
        print(x + " ")
        preorder_tree_walk(x.left)
        preorder_tree_walk(x.right)

def postorder_tree_walk(x):
    '''
    12.1.4
    scan all keys by postorder tree walk method

    Parameters:
        x - the root of the binary search tree
    Returns:
        none
    '''
    if x != None:
        postorder_tree_walk(x)
        postorder_tree_walk(x)
        print(x + " ")

def tree_search(x, k):
    '''
    12.2
    search the given key of the binary search tree

    Parameters:
        x - the root of the binary search tree
        k - the key need to search
    Returns:
        the node that contains the k
    '''
    if x == None or k == x.value:
        return x
    if k < x.value:
        return tree_search(x.left, k)
    else:
        return tree_search(x.right, k)

def interative_tree_search(x, k):
    '''
    12.2
    the unrolling version of searching the binary search tree

    Parameters:
        x - the root of the binary search tree
        k - the key need to search
    Returns:
        the node that contains the k
    '''
    while x != None and k != x.value:
        if k < x.value:
            x = x.left
        else:
            x = x.right
    return x

def tree_minimum(x):
    '''
    12.2
    find the minimum key of the binary search tree

    Parameters:
        x - the root of the binary search tree
    Returns:
        the node that contains the minimum key 
    '''
    if x == None:
        return None
    while x.left != None:
        x = x.left
    return x

def tree_maximum(x):
    '''
    12.2
    find the maximum key of the binary search tree

    Parameters:
        x - the root of the binary search tree
    Returns:
        the node that contains the maximum key
    '''
    if x == None:
        return None
    while x.right != None:
        x = x.right
    return x

def tree_successor(x):
    '''
    12.2
    find the successor of the given node

    Parameters:
       x - the node need to find the successor
    Returns:
        the node which contains the successor of x
    '''
    if x.right != None:
        return tree_minimum(x.right)
    y = x.p
    while y != None and x == y.right:
        x = y
        y = y.p
    return None

def tree_predecessor(x):
    '''
    12.2.3
    find the predecessor of the given node

    Parameters:
        x - the node need to find the predecessor
    Returns:
        the node whick contains the predecessor of x
    '''
    if x.left != None:
        return tree_maximum(x.left)
    return x.p

def tree_insert(t, x):
    '''
    12.3
    insert the given node into the binary search tree

    Parameters:
        t - the given binary search tree
        x - the node needs to insert into the binary search tree
    Returns:
        none
    '''
    y = None
    x = t.root
    while x != None:
        y = x
        if z.value < x.value:
            x = x.left
        else:
            x = x.right
    z.p = y
    if y == None:
        t.root = z
    elif z.key < y.key:
        y.left = z
    else:
        y.right = z


def transplant(t, u, v):
    '''
    move subtrees around within the binary search tree

    Parameters:
        t - the given binary tree
        u - the subtree was to be replaced
        v - the subtree used to replacing the subtree u
    Return:
        None
    '''
    if u.p == None:
        t.root = v
    elif u == u.p.left:
        u.p.left = v
    else:
        u.p.right = v
    if v != None:
        v.p = u.p

def tree_delete(t, z):
    '''
    delete the given node z which belongs to the tree t
    '''
    if z.left == None:
        transplant(t, z, z.right)
    elif z.right == None:
        transplant(t, z, z.left)
    else:
        y = tree_minimum(z.right)
        if y.p != z:
            transplant(t, y, y.right)
            y.right = z.right
            y.right.p = y
        transplant(t, z, y)
        y.left = z.left
        y.left.p = y