数据结构与算法（1）--二叉树

博客记录的第一个算法：

实现二叉树数据结构，以及深度优先搜索和广度优先搜索算法（非科班小白，努力中。。。。） 

class BT_Node:                                                  
    def __init__(self, data, left = None, right = None):        
        self.data = data                                        
        self.left = left                                        
        self.right = right                                      
                                                                
class BTree:                                                    
    def __init__(self):                                         
       self.root = None      # None创建空树，不是BT_Node树节点            
                                                                
    def set_root(self, node):                                   
        self.root = node                                        
                                                                
    def is_empty(self):                                         
        return self.root == None                                
                                                                
    def addLeft(self, node):                                    
        if self.is_empty():                                     
            self.root = node                                    
        else:                                                   
            self.root.left = node                               
                                                                
    def addRight(self, node):                                   
        if self.is_empty():                                     
            self.root = node                                    
        else:                                                   
            self.root.right = node                              
                                                                
#  深度优先搜索(先根序)                                                  
def dfs_front(node):                                            
    if node == None:                                            
        return                                                  
    print(str(node.data)+"→", end="")                           
    dfs_front(node.left)                                        
    dfs_front(node.right)                                       
                                                                
#  深度优先搜索(中根序)                                                  
def dfs_middle(node):                                           
    if node == None:                                            
        return                                                  
    dfs_middle(node.left)                                       
    print(str(node.data) + "→", end="")                         
    dfs_middle(node.right)                                      
                                                                
#  深度优先搜索(后根序)                                                  
def dfs_after(node):                                            
    if node == None:                                            
        return                                                  
    dfs_after(node.left)                                        
    dfs_after(node.right)                                       
    print(str(node.data) + "→", end="")                         
                                                                
#  宽度优先搜索                                                       
def bfs(node):                                                  
    if not node:                                                
        print("this is an empty tree")                          
    st = []      #List做为队列缓存,先进先出                               
    st.append(node)                                             
    while st:                                                   
        temp = st[0]                                            
        print(str(temp.data)+"→", end="")                       
        del st[0]                                               
        if temp.right:                                          
            st.append(temp.left)                                
        if temp.left:                                           
            st.append(temp.right)                               
                                                                
# 以下为测试部分                                                       
t = BTree()                                                     
t.set_root(BT_Node(4))                                          
t.addLeft(BT_Node(5,BT_Node(6),BT_Node(7)))                     
t.addRight(BT_Node(8,BT_Node(9),BT_Node(10)))                   
print("先根序：")                                                   
dfs_front(t.root)                                               
print("\n中根序：")                                                 
dfs_middle(t.root)                                              
print("\n后根序：")                                                 
dfs_after(t.root)                                               
print("\n宽度优先搜索：")                                              
bfs(t.root)                                                     
                                                                

  输出结果如下：

"E:\Program Files\python 3.7\python.exe" C:/Users/Administrator/Desktop/python学习/数据结构与算法/BTree.py
先根序：
4→5→6→7→8→9→10→
中根序：
6→5→7→4→9→8→10→
后根序：
6→7→5→9→10→8→4→
宽度优先搜索：
4→5→8→6→7→9→10→
Process finished with exit code 0