二叉查找树（binary search tree）——python实现

二叉查找树（binary search tree）

顾名思义二叉查找树中每个节点至多有两个子节点，并且还对存储于每个节点中的关键字值有个小小的要求，

即只要这个节点有左节点或右节点，那么其关键字值总的大于其左节点的关键字值，小于其右节点的关键字值，如下图：

因为树的结构特性，很适合使用递归的方式去操作，下面的实现中均是以递归的方式实现：

下面仅给出了python的实现，一是因为代码太长，二是python的实现是我对着C语言实现改过来的，基本没什么差别；

主要实现的方法有：

• 遍历：

前序：preorder()——理根节点→处理左子树→处理右子树

中序：inorder()——处理左子树→处理根节点→处理右子树

后序：postorder()——处理左子树→处理右子树→处理根节点

• 插入：

insert(key)——将关键字值为key的节点插入到适当的位置（注释里面的是非递归实现）

• 删除：

delete(key)——将关键字值为key的节点从树中删掉(注释中给了说明)

• 获取高度：

height()

• 获取树中的节点数：

count()

• 查找：

find(key)——查找关键字值为key的节点（二叉查找树的一个重要应用就是在查找中）

• 获取树中最大key值节点和最key值小节点：

find_max()

find_min()

；；；

class tree_node:
    def __init__(self, key = None, left = None, right = None):
        self.key = key
        self.left = left
        self.right = right

class binary_search_tree:
    def __init__(self):
        self.root = None

    def preorder(self):
        print 'preorder: ',
        self.__preorder(self.root)
        print

    def __preorder(self, root):
        if not root:
            return
        print root.key,
        self.__preorder(root.left)
        self.__preorder(root.right)

    def inorder(self):
        print 'inorder: ',
        self.__inorder(self.root)
        print

    def __inorder(self, root):
        if not root:
            return
        self.__inorder(root.left)
        print root.key,
        self.__inorder(root.right)

    def postorder(self):
        print 'postorder: ',
        self.__postorder(self.root)
        print

    def __postorder(self, root):
        if not root:
            return
        self.__postorder(root.left)
        self.__postorder(root.right)
        print root.key,

    def insert(self, key):
        '''recursion'''
        self.root = self.__insert(self.root, key)
        
    def __insert(self, root, key):
        if not root:
            root = tree_node(key)
        else:
            if key < root.key:
                root.left = self.__insert(root.left, key)
            elif key > root.key:
                root.right = self.__insert(root.right, key)
            else:
                print key, 'is already in tree'
                
        return root
    
##non-recursion
##    def insert(self, key):
##        if not self.root:
##            self.root = tree_node(key)
##        else:
##            cur = self.root
##            while True:
##                if key < cur.key:
##                    if not cur.left:
##                        cur.left = tree_node(key)
##                        break
##                    cur = cur.left
##                elif key > cur.key:
##                    if not cur.right:
##                        cur.right = tree_node(key)
##                        break
##                    cur = cur.right
##                else:
##                    print key, 'in tree'
##                    break

    def height(self):
        return self.__height(self.root)
    
    def __height(self, root):
        if not root:
            return -1
        left_height = self.__height(root.left)
        right_height = self.__height(root.right)
        #return 1+(left_height if left_height>right_height else right_height)#这种方式是自己写的，后面两种高大上的是网上偷学的^_^
        #return 1+[left_height,right_height][left_height<right_height]
        return 1+(left_height>right_height and [left_height] or [right_height])[0]

    def count(self):
        '''elements in tree'''
        return self.__count(self.root)

    def __count(self, root):
        if not root:
            return 0
        return 1+self.__count(root.left)+self.__count(root.right)

    def delete(self, key):
        self.root = self.__delete(self.root, key)
##
##删除操作：
##首先找到删除的节点，
##1. 如果左右子树都不为空，则找到右子树中最小的节点min，用min.key代替删除节点的key，然后再到右子
##	 树中删除min节点,因为min没有左节点，所以删除它的话只需要用它的右节点代替它(如果有右节点)；
##2. 如果左子树或者右子树不为空，则直接代替掉
##3. 如果左右均空即叶子节点，直接删掉
    def __delete(self, root, key):
        if not root:
            print 'not find key: ', key
        elif key < root.key:
            root.left = self.__delete(root.left, key)
        elif key > root.key:
            root.right = self.__delete(root.right, key)
        elif root.left and root.right: #found
            right_min = self.__find_min(self.root.right)
            root.key = right_min.key
            root.right = self.__delete(root.right, right_min.key)
        elif root.left:
            root = root.left
        elif root.right:
            root = root.right
        else:
            root = None #python的GC会在没有引用指向对象的时候销毁对象

        return root

    def find(self, key):
        node = self.__find(self.root, key)
        if not node:
            print 'not found'
        return node
        

    def __find(self, root, key):
        if not root:
            return None
        if key < root.key:
            return self.__find(root.left, key)
        elif key > root.key:
            return self.__find(root.right, key)
        else:
            return root

    def find_min(self):
        return self.__find_min(self.root)

    def __find_min(self, root):
        if not root.left:
            return root
        return self.__find_min(root.left)

    def find_max(self):
        return self.__find_max(self.root)

    def __find_max(self, root):
        if not root.right:
            return root
        return self.__find_max(root.right)


def main():
    import random
    root = binary_search_tree()
    for i in random.sample([j for j in range(1, 100)], 5):
        root.insert(i)
    print 'insert: '
    root.insert(78)
    root.insert(101)
    root.insert(14)
    
    root.preorder()
    root.inorder()
    root.postorder()
    print 'height: ', root.height()
    print 'count: ', root.count()
    print 'min: ', root.find_min().key
    print 'max: ', root.find_max().key
    
    print 'delete: '
    root.delete(101)
    root.delete(12)
    
    root.preorder()
    root.inorder()
    root.postorder()
    print root.find(71)
    print root.find(78)
    print 'height: ', root.height()
    print 'count: ', root.count()
    print 'min: ', root.find_min().key
    print 'max: ', root.find_max().key
    
if __name__ == '__main__':
    main()