Python -二叉樹 創建與遍歷算法(很詳細)


樹表示由邊連接的節點。它是一個非線性的數據結構。它具有以下特性。

  1. 一個節點被標記為根節點。
  2. 除根節點之外的每個節點都與一個父節點關聯。
  3. 每個節點可以有一個arbiatry編號的chid節點。

我們使用前面討論的os節點概念在python中創建了一個樹數據結構。我們將一個節點指定為根節點,然后將更多的節點添加為子節點。下面是創建根節點的程序。

創建樹

創建根

我們只需要創建一個節點類並向節點添加賦值。這就變成了只有根節點的樹。

 1 class Node:
 2 
 3     def __init__(self, data):
 4         self.left = None  #左節點
 5         self.right = None #右節點
 6         self.data = data  #
 7 
 8     def PrintTree(self):
 9         print(self.data)
10 
11 root = Node(10) #創建節點
12 
13 root.PrintTree()

當執行上述代碼時,將產生以下結果-

10

插入到樹中

要插入到樹中,我們使用上面創建的相同節點類,並向其添加一個插入類。insert類將節點的值與父節點的值進行比較,並決定將其添加為左節點或右節點。最后,PrintTree類用於打印樹。

 1 class Node:
 2     def __init__(self, data):
 3         self.left = None
 4         self.right = None
 5         self.data = data
 6 
 7     def insert(self, data):
 8     # 將新值與父節點進行比較
 9         if self.data:  # 非空
10             if data < self.data:            #新值較小,放左邊
11                 if self.left is None:       #若空,則新建插入節點
12                     self.left = Node(data)
13                 else:                       #否則,遞歸往下查找
14                     self.left.insert(data)
15             elif data > self.data:          #新值較大,放右邊
16                 if self.right is None:      #若空,則新建插入節點
17                     self.right = Node(data)
18                 else:                       #否則,遞歸往下查找
19                     self.right.insert(data)
20         else:
21             self.data = data                
22 
23     # 打印這棵樹,中序遍歷
24     def PrintTree(self):
25         if self.left:
26             self.left.PrintTree()
27         print( self.data),
28         if self.right:
29             self.right.PrintTree()
30 
31 # 使用insert方法添加節點
32 root = Node(12)
33 root.insert(6)
34 root.insert(14)
35 root.insert(3)
36 
37 root.PrintTree()

 

當執行上述代碼時,將產生以下結果-

3 6 12 14

遍歷樹

可以通過決定訪問每個節點的序列來遍歷樹。我們可以清楚地看到,我們可以從一個節點開始,然后首先訪問左子樹,然后訪問右子樹。或者我們也可以先訪問右子樹然后訪問左子樹。因此,這些樹遍歷方法有不同的名稱。我們將在實現樹遍歷算法的章節中詳細研究它們。

Python樹遍歷算法

遍歷是一個訪問樹的所有節點的過程,也可以打印它們的值。因為,所有節點都是通過邊(鏈接)連接的,所以我們總是從根(頭)節點開始。也就是說,我們不能隨機訪問樹中的節點。我們走過一棵樹有三種方法

  1. 先序遍歷
  2. 中序遍歷
  3. 后序遍歷

順序遍歷

在這個遍歷方法中,首先訪問左子樹,然后訪問根,然后訪問右子樹。我們應該始終記住,每個節點都可以表示子樹本身。
在下面的python程序中,我們使用Node類為根節點以及左右節點創建位置占位符。然后我們創建一個insert函數來向樹中添加數據。最后,通過創建一個空列表並首先添加左節點,然后添加根節點或父節點來實現order遍歷邏輯。最后添加左節點來完成order遍歷。

 1 class Node:
 2 
 3     def __init__(self, data):
 4 
 5         self.left = None
 6         self.right = None
 7         self.data = data
 8 # Insert Node
 9     def insert(self, data):
10 
11         if self.data:
12             if data < self.data:
13                 if self.left is None:
14                     self.left = Node(data)
15                 else:
16                     self.left.insert(data)
17             elif data > self.data:
18                 if self.right is None:
19                     self.right = Node(data)
20                 else:
21                     self.right.insert(data)
22         else:
23             self.data = data
24 
25 # Print the Tree
26     def PrintTree(self):
27         if self.left:
28             self.left.PrintTree()
29         print( self.data),
30         if self.right:
31             self.right.PrintTree()
32 
33 # 中序遍歷
34 # Left -> Root -> Right
35     def inorderTraversal(self, root):
36         res = []
37         if root:
38             res = self.inorderTraversal(root.left)
39             res.append(root.data)
40             res = res + self.inorderTraversal(root.right)
41         return res
42 
43 root = Node(27)
44 root.insert(14)
45 root.insert(35)
46 root.insert(10)
47 root.insert(19)
48 root.insert(31)
49 root.insert(42)
50 print(root.inorderTraversal(root))

 

當執行上述代碼時,將產生以下結果-

[10、14、19、27、31、35、42]

預購遍歷

在這種遍歷方法中,首先訪問根節點,然后訪問左子樹,最后訪問右子樹。
在下面的python程序中,我們使用Node類為根節點以及左右節點創建位置占位符。然后我們創建一個insert函數來向樹中添加數據。最后,通過創建一個空列表並首先添加根節點,然后添加左節點來實現預排序遍歷邏輯。最后添加正確的節點來完成預定遍歷。請注意,此過程對每個子樹重復,直到所有t

 1 class Node:
 2 
 3     def __init__(self, data):
 4 
 5         self.left = None
 6         self.right = None
 7         self.data = data
 8 # Insert Node
 9     def insert(self, data):
10 
11         if self.data:
12             if data < self.data:
13                 if self.left is None:
14                     self.left = Node(data)
15                 else:
16                     self.left.insert(data)
17             elif data > self.data:
18                 if self.right is None:
19                     self.right = Node(data)
20                 else:
21                     self.right.insert(data)
22         else:
23             self.data = data
24 
25 # Print the Tree
26     def PrintTree(self):
27         if self.left:
28             self.left.PrintTree()
29         print( self.data),
30         if self.right:
31             self.right.PrintTree()
32 
33 # 先序遍歷
34 # Root -> Left ->Right
35     def PreorderTraversal(self, root):
36         res = []
37         if root:
38             res.append(root.data)
39             res = res + self.PreorderTraversal(root.left)
40             res = res + self.PreorderTraversal(root.right)
41         return res
42 
43 root = Node(27)
44 root.insert(14)
45 root.insert(35)
46 root.insert(10)
47 root.insert(19)
48 root.insert(31)
49 root.insert(42)
50 print(root.PreorderTraversal(root))

 

當執行上述代碼時,將產生以下結果-

[27, 14, 10, 19, 35, 31, 42]

后序遍歷

在這個遍歷方法中,根節點最后訪問,因此得名。首先遍歷左子樹,然后遍歷右子樹,最后遍歷根節點。

在下面的python程序中,我們使用Node類為根節點以及左右節點創建位置占位符。然后我們創建一個insert函數來向樹中添加數據。最后,通過創建一個空列表並先添加左節點后添加右節點來實現后序遍歷邏輯。最后添加根節點或父節點來完成后序遍歷。請注意,此過程將對每個子樹重復,直到遍歷所有節點。

 1 class Node:
 2 
 3     def __init__(self, data):
 4 
 5         self.left = None
 6         self.right = None
 7         self.data = data
 8 # Insert Node
 9     def insert(self, data):
10 
11         if self.data:
12             if data < self.data:
13                 if self.left is None:
14                     self.left = Node(data)
15                 else:
16                     self.left.insert(data)
17             elif data > self.data:
18                 if self.right is None:
19                     self.right = Node(data)
20                 else:
21                     self.right.insert(data)
22         else:
23             self.data = data
24 
25 # Print the Tree
26     def PrintTree(self):
27         if self.left:
28             self.left.PrintTree()
29         print( self.data),
30         if self.right:
31             self.right.PrintTree()
32 
33 # 后序遍歷
34 # Left ->Right -> Root
35     def PostorderTraversal(self, root):
36         res = []
37         if root:
38             res = self.PostorderTraversal(root.left)
39             res = res + self.PostorderTraversal(root.right)
40             res.append(root.data)
41         return res
42 
43 root = Node(27)
44 root.insert(14)
45 root.insert(35)
46 root.insert(10)
47 root.insert(19)
48 root.insert(31)
49 root.insert(42)
50 print(root.PostorderTraversal(root))

 

當執行上述代碼時,將產生以下結果-

[10、19、14、31、42、35、27]

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM