【练习册】 2015-08-10 ClassicTrie by python

#!/usr/bin/python
#coding=utf-8

class Node:
    def __init__(self, data=None, left=None, right=None):
        self.data = data
        self.right = left
        self.left = right

class ClassicTrie:
    #init root  
    def __init__ (self,root=None):
        self.root=root
        
#     def isEmpty(self):
#         if self.root==None:
#             return True
#         else:
#             return False

    def find(self,cmp_data,find_list=[]):
        # return node
        def compara(start_node,cmp_data):           
            find_list.append(start_node)
            if start_node.data == cmp_data:
                return start_node
            elif start_node.data > cmp_data and start_node.right != None:
                return compara(start_node.right, cmp_data)
            elif start_node.data < cmp_data and start_node.left != None: 
                return compara(start_node.left, cmp_data)
            else:
                raise ValueError
                     
        return compara(self.root,cmp_data)
        
    def find_rtree_min(self,start_node):
        # return node
        def sub_findmin(start_node):            
            if start_node.right == None:
                return start_node
            else:
                return sub_findmin(start_node.right)
            
        return sub_findmin(start_node.left)
        
    def insert(self,ins_node):
        flag_side=0 #left=0,right=1
        def location(father_node):
            nonlocal flag_side
            if ins_node.data < father_node.data:
                if father_node.right==None :
                    flag_side = 0
                    return father_node
                else:
                    return location(father_node.right)
            elif ins_node.data > father_node.data:
                if  father_node.left== None :
                    flag_side = 1
                    return father_node
                else:
                    return location(father_node.left)
            else:
                print("the father_node already exit !")
                raise ValueError
        
        tmp=location(self.root)
        
        if flag_side==0 :
            tmp.right=ins_node 
        else: 
            tmp.left=ins_node
        

    
    def remove(self,rm_node):
        min_node_data=None
        def sub_remove(rm_node):
            find_list=[]
            self.find(rm_node.data, find_list)
          
            
            if rm_node.right == None and rm_node.left == None:
                # rm_node is leaf node
                print("rm_node is leaf node")
                if find_list[-2].right == rm_node:
                    find_list[-2].right = None
                else :
                    find_list[-2].left = None         
      
    
            elif rm_node.right == None or rm_node.left == None:   
                # rm_node with only 1 child node
                print("rm_node with only 1 child node",rm_node.data)
                if find_list[-2].right == rm_node:
                    if rm_node.right != None:
                        find_list[-2].right=rm_node.right
                    else:
                        find_list[-2].right=rm_node.left
                else: 
                    if rm_node.right != None:
                        find_list[-2].left=rm_node.right                    
                    else:
                        find_list[-2].left=rm_node.left
                        
            else:
                # rm_node with 2 child node
                print("rm_node with 2 child node", rm_node.data)
                min_node=self.find_rtree_min(rm_node)
                
                nonlocal min_node_data
                min_node_data=min_node.data
                sub_remove(min_node)
        
        sub_remove(rm_node)
        rm_node.data=min_node_data
    
    
    def PreOrderTraverse(self):
        tracelist=[]
        def PreTr(node):
            #遍历方法
            if node:
                tracelist.append(node.data)
                #print (node.data,end=',')  
                PreTr(node.right)                   
                PreTr(node.left)
              
        PreTr(self.root)
        print ('tracing =' ,tracelist)  



if __name__ == '__main__':

    n6=Node(6)
    n2=Node(2)
    n8=Node(8)
    n1=Node(1)
    n4=Node(4)
    n3=Node(3)
    n5=Node(5)
    n7=Node(7)
    
    t=ClassicTrie(n6)
    t.insert(n2)
    t.insert(n1)
    t.insert(n5)
    t.insert(n3)
    t.insert(n4)
    t.insert(n8)
    
    print("######## trace function #####")
    t.PreOrderTraverse()

    print("######## find function ########")
    find_list=[]
    print(t.find(3,find_list).data)
    
    print("######## find_rtree_min function ########")
    findmin_list=[]
    print(t.find_rtree_min(n2).data)  
      
    print("######## remove function ########")
    t.remove(n2)
    t.PreOrderTraverse()
    #print(n4.right.data)
    
    
    

对经典Trie的练习