python3實現二叉樹的遍歷與遞歸算法解析

1、二叉樹的三種遍歷方式

　　二叉樹有三種遍歷方式：先序遍歷，中序遍歷，后續遍歷  即：先中后指的是訪問根節點的順序   eg:先序 根左右   中序 左根右  后序  左右根

　　遍歷總體思路：將樹分成最小的子樹，然后按照順序輸出

            

 

　　1.1 先序遍歷  

　　　　a 先訪問根節點

　　　　b 訪問左節點

　　　　c 訪問右節點         

　　　　a（b ( d ( h ) )( e ( i ) )）( c ( f )( g ))      --   abdheicfg  

　　1.2 中序遍歷

　　　　a 先訪問左節點

　　　　b 訪問根節點

　　　　c 訪問右節點

　　　　( ( ( h ) d ) b ( ( i ) e ) ) a ( ( f ) c ( g ) )  -- hdbieafcg

　　1.3后序遍歷

　　　　a 先訪問左節點

　　　　b 訪問右節點

　　　　c 訪問根節點

　　　　((hd)(ie)b)(fgc)a  -- hdiebfgca

2、python3實現樹結構

#實現樹結構的類，樹的節點有三個私有屬性  左指針 右指針 自身的值
class Node():

    def __init__(self,data=None):
        self._data = data
        self._left = None
        self._right = None

    def set_data(self,data):
        self._data = data

    def get_data(self):
        return self._data

    def set_left(self,node):
        self._left = node

    def get_left(self):
        return self._left

    def set_right(self,node):
        self._right = node

    def get_right(self):
        return self._right

if __name__ == '__main__':
    #實例化根節點
    root_node = Node('a')
    # root_node.set_data('a')
    #實例化左子節點
    left_node = Node('b')
    #實例化右子節點
    right_node = Node('c')
    
    #給根節點的左指針賦值，使其指向左子節點
    root_node.set_left(left_node)
    #給根節點的右指針賦值，使其指向右子節點
    root_node.set_right(right_node)

    print(root_node.get_data(),root_node.get_left().get_data(),root_node.get_right().get_data())

3、實現樹的遞歸遍歷（前 中 后 層次遍歷）

   下例是樹的遍歷算法，其中對樹的類進行了優化，

#實現樹結構的類，樹的節點有三個私有屬性  左指針 右指針 自己的值
class Node():

    def __init__(self,data =None,left=None,right = None):
        self._data = data
        self._left = left
        self._right = right


#先序遍歷  遍歷過程 根左右
def pro_order(tree):
    if tree == None:
        return False
    print(tree._data)
    pro_order(tree._left)
    pro_order(tree._right)

#后序遍歷
def pos_order(tree):
    if tree == None:
        return False
    # print(tree.get_data())
    pos_order(tree._left)
    pos_order(tree._right)
    print(tree._data)

#中序遍歷
def mid_order(tree):
    if tree == None:
        return False
    # print(tree.get_data())
    mid_order(tree._left)
    print(tree._data)
    mid_order(tree._right)


#層次遍歷
def row_order(tree):
    # print(tree._data)
    queue = []
    queue.append(tree)
    while True:
        if queue==[]:
            break
        print(queue[0]._data)
        first_tree = queue[0]
        if first_tree._left != None:
            queue.append(first_tree._left)
        if first_tree._right != None:
            queue.append(first_tree._right)
        queue.remove(first_tree)

if __name__ == '__main__':

    tree = Node('A',Node('B',Node('D'),Node('E')),Node('C',Node('F'),Node('G')))
    pro_order(tree)
    mid_order(tree)
    pos_order(tree)

 

4、遞歸算法

 上面兩張圖片是從知乎貼過來的；圖1中返回后會直接返回到上一級的返回，這種想法是不全面的，較合理的返回應該是如圖2 在子函數返回時應返回到調用子函數的節點，這樣在執行完剩余代碼再返回到上一級

如果是按照圖1返回的話二叉樹的遍歷就不能按照上例來實現。

#遞歸求N!
def recursive_mix(n):
    if n == 2:
        return 1
    return n*recursive_mix(n-1)


#十進制轉二進制
def recursive_conversion(n):
    if n == 0:
        return

    recursive_conversion(int(n/2))
    print(n%2)
    # return n%2

#遞歸實現數字倒敘
def recursive_back(n):
    if n ==0:
        return
    print(n%10)
    recursive_back(int(n/10))

recursive_conversion(23)
recursive_mix(5)
recursive_back(1234)