python 二叉搜索树

python 二叉搜索树

1. 首先定义二叉搜索树的节点类

   class TreeNode(object):
       def __init__(self,data):
           self.val = data
           self.left = None
           self.right = None
   

2. 添加节点

   二叉搜索树的特点：左子树的值小于父节点值，右子树的值大于父节点的值

   可以递归的添加节点

   	def add_node(self,data):
           def re_curr(node, data):    
               if data >= node.val:
                   if not node.right:
                       node.right = TreeNode(data)
                   else:
                       re_curr(node.right, data)
               elif data < node.val:
                   if not node.left:
                       node.left = TreeNode(data)
                   else:
                       re_curr(node.left, data)
   
           if self.root is None:
               self.root = TreeNode(data)
           else:
               re_curr(self.root,data)
   

3. 搜索节点

	def search(self, data):
		#return :是否搜索到，父节点，节点
        if self.root is None:
            return False,None, None
        else:
            def find(p_node,node,data):
                if node is None:
                    return False,None, None
                else:
                    if data == node.val:
                        return True,p_node, node
                if data > node.val:
                    return find(node, node.right, data)
                if data < node.val:
                    return find(node, node.left, data)
            return find(None, self.root,data)

4. 计算树的最大值

   树的最右下角的节点即为最大值对应的节点

   def search_max_data(self):
           #递归法求最大值
           if self.root is None:
               return None
           else:
               def re_curr(node):
                   if not node.right:
                       return node.val
                   else:
                       return re_curr(node.right)
               return re_curr(self.root)
   
       def search_max_data_2(self):
           #非递归法求最大值
           if self.root is None:
               return None
           else:
               node = self.root.right
               while node.right is not None:
                   node = node.right
               return node.val
   

5. 删除节点

   	def delete_item(self, data):
           flag, p, n = self.search(data) #搜索数值对应的节点
           if flag is False:
               print "delete error:could not find the deleted item!!"
               return 
           else:
           	#如果节点的左子树或者右子树为空，则将其左子树或者右子树替代该节点
               if n.left is None:
                   if p.left == n:
                       p.left = n.right
                   else:
                       p.right = n.right
                       del n 
               elif n.right is None:
                   if p.left == n:
                       p.left = n.left
                   else:
                       p.right = n.left
                       del n
               else:
               	#如果该节点的左右子树都存在
                   pre = n.right
                   if pre.left is None:
                       n.data = pre.data
                       n.right=pre.right
                       del pre 
                   else:
                       next = pre.left
                       while next.left is not None:
                           pre = next
                           next = next.left
                       n.data = next.data
                       pre.left = next.right
                       del next 
   

完整代码：

#coding:utf-8
class TreeNode(object):
    def __init__(self,data):
        self.val = data
        self.left = None
        self.right = None

class BiSearchTree(object):
    def __init__(self, data_list):
        self.root = None
        for i in data_list:
            self.add_node(i)


    def add_node(self,data):
        def re_curr(node, data):    
            if data >= node.val:
                if not node.right:
                    node.right = TreeNode(data)
                else:
                    re_curr(node.right, data)
            elif data < node.val:
                if not node.left:
                    node.left = TreeNode(data)
                else:
                    re_curr(node.left, data)

        if self.root is None:
            self.root = TreeNode(data)
        else:
            re_curr(self.root,data)
                

    def search(self, data):
        if self.root is None:
            return False,None, None
        else:
            def find(p_node,node,data):
                if node is None:
                    return False,None, None
                else:
                    if data == node.val:
                        return True,p_node, node
                if data > node.val:
                    return find(node, node.right, data)
                if data < node.val:
                    return find(node, node.left, data)
            return find(None, self.root,data)

            
    def search_max_data(self):
        #递归法求最大值
        if self.root is None:
            return None
        else:
            def re_curr(node):
                if not node.right:
                    return node.val
                else:
                    return re_curr(node.right)
            return re_curr(self.root)

    def search_max_data_2(self):
        #非递归法求最大值
        if self.root is None:
            return None
        else:
            node = self.root.right
            while node.right is not None:
                node = node.right
            return node.val


    def print_tree(self, root):
        if not root:
            return 
        self.print_tree(root.left)
        print root.val, "*"*30
        self.print_tree(root.right)

    def delete_item(self, data):
        flag, p, n = self.search(data)
        if flag is False:
            print "delete error:could not find the deleted item!!"
            return 
        else:
            if n.left is None:
                if p.left == n:
                    p.left = n.right
                else:
                    p.right = n.right
                    del n 
            elif n.right is None:
                if p.left == n:
                    p.left = n.left
                else:
                    p.right = n.left
                    del n
            else:
                pre = n.right
                if pre.left is None:
                    n.data = pre.data
                    n.right=pre.right
                    del pre 
                else:
                    next = pre.left
                    while next.left is not None:
                        pre = next
                        next = next.left
                    n.data = next.data
                    pre.left = next.right
                    del next 
        

li = [5,9,10,2,1,3,11]
bi_search_tree = BiSearchTree(li)
bi_search_tree.print_tree(bi_search_tree.root)
for i in range(30):
    print i, bi_search_tree.search(i)
print "*"*30
for data in [3,11]:
    bi_search_tree.delete_item(data)
bi_search_tree.print_tree(bi_search_tree.root)
print "-"*30, "二叉搜索树的最大值:"
print bi_search_tree.search_max_data()
print bi_search_tree.search_max_data_2()