目錄
二叉樹
顧名思義，二叉樹就是隻有兩個節點的樹，兩個節點分別爲左節點和右節點，特別強調，即使只有一個子節點也要區分它是左節點還是右節點。
常見的二叉樹有一般二叉樹、完全二叉樹、滿二叉樹、線索二叉樹、霍夫曼樹、二叉排序樹、平衡二叉樹、紅黑樹、B樹這麼多種類。我們這篇文章中簡單介紹一般二叉樹、完全二叉樹和滿二叉樹。
一般二叉樹
很簡單，只要滿足子節點數不超過兩個的樹就是一棵二叉樹。長這樣：
滿二叉樹
滿二叉樹在一般二叉樹的基礎上要求除了最後一層的節點之外，每一個節點都必須有兩個子節點。
完全二叉樹
完全二叉樹要求從第一層到倒數第二層組成的樹是一顆滿二叉樹，最後一層的節點要滿足從左往右排列。
好，關於二叉樹的概念，我們就介紹到這裏，下面我們來介紹二叉樹的前序、中序、後序遍歷。
在此之前呢，我們先創建一顆二叉樹：
class BinaryTree:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get(self):
return self.data
def getLeft(self):
return self.left
def getRight(self):
return self.right
def setLeft(self, node):
self.left = node
def setRight(self, node):
self.right = node
好，這裏我們定義好了一個二叉樹類，並給它添加了一下方法，然後我們來實例化一顆二叉樹：
binaryTree = BinaryTree(0)
binaryTree.setLeft(BinaryTree(1))
binaryTree.setRight(BinaryTree(2))
binaryTree.getLeft().setLeft(BinaryTree(3))
binaryTree.getLeft().setRight(BinaryTree(4))
binaryTree.getRight().setLeft(BinaryTree(5))
binaryTree.getRight().setRight(BinaryTree(6))
實例化好的二叉樹是長這個樣子的：
二叉樹的遞歸遍歷實現
前序遍歷
接下來，我們對這棵樹進行前序遍歷。在此之前，我們介紹一下什麼是前序遍歷。
前面我們介紹過了樹的深度優先遍歷和廣度優先遍歷，這裏就不再贅述了。
前序遍歷的順序就是先遍歷樹的父節點，然後遍歷樹的左節點，然後遍歷樹的右節點，以此類推。
對於我們上面定義好的二叉樹來說，它的前序遍歷結果就是：0 -> 1 -> 3 -> 4 -> 2 -> 5 -> 6
對於前序、中序、後序遍歷來說，採用遞歸的方式是非常方便的。這裏我們就用遞歸來實現一下：
def preorderTraversal(now, result=[]):
if now == None:
return result
result.append(now.data)
preorderTraversal(now.left, result)
preorderTraversal(now.right, result)
return result
print(preorderTraversal(binaryTree))
執行結果：[0, 1, 3, 4, 2, 5, 6]，是不是和我們之前手動遍歷的結果一樣呢。
中序遍歷
中序遍歷的順序是：先遍歷樹的左節點，再遍歷樹的父節點，再遍歷樹的右節點。
對於我們上面創建的二叉樹，它的中序遍歷結果就是：3 -> 1 -> 4 -> 0 -> 5 -> 2 -> 6
在前序遍歷的時候是先遍歷父節點，所以result.append(now.data)，就在遍歷左節點和右節點的前面。
而中序遍歷要先遍歷左節點，所以result.append(now.data)就要在遍歷左節點的後面，遍歷右節點的前面。
def intermediateTraversal(now, result=[]):
if now == None:
return result
intermediateTraversal(now.left, result)
result.append(now.data)
intermediateTraversal(now.right, result)
return result
print(intermediateTraversal(binaryTree))
執行結果：[3, 1, 4, 0, 5, 2, 6]
後序遍歷
後序遍歷順序是：先遍歷樹的左節點，再遍歷樹的右節點，再遍歷樹的父節點。
對於我們上面創建的二叉樹，它的後序遍歷結果是：3 -> 4 -> 1 -> 5 -> 6 -> 2 -> 0
相應的遞歸方程爲：
def postorderTraversal(now, result=[]):
if now == None:
return
postorderTraversal(now.left, result)
postorderTraversal(now.right, result)
result.append(now.data)
return result
print(postorderTraversal(binaryTree))
執行結果：[3, 4, 1, 5, 6, 2, 0]
二叉樹的遍歷之迭代方式實現
（包括前序、中序和後序）
#二叉樹的前序遍歷
#思想：主要會用到數據結構 stack, 不說廢話，直接上代碼;
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
if root is None:
return []
stack = []
result = []
stack.append(root)
while(len(stack) > 0):
node = stack.pop()
result.append(node.val)
if node.right:
stack.append(node.right)
if node.left:
stack.append(node.left)
return result
#二叉樹的中序遍歷
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def inorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
if root is None:
return []
stack = []
result = []
node = root
while node or (len(stack) > 0):
if node:
stack.append(node)
node = node.left
else:
node = stack.pop()
result.append(node.val)
node = node.right
return result
#二叉樹的後序遍歷
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def postorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
if root is None:
return []
stack1 = []
stack2 = []
result = []
stack1.append(root)
while len(stack1) > 0:
node = stack1.pop()
stack2.append(node)
if node.left:
stack1.append(node.left)
if node.right:
stack1.append(node.right)
while(len(stack2) > 0):
top = stack2.pop()
result.append(top.val)
return result
相關參考：
https://www.cnblogs.com/dongyangblog/p/11210820.html
https://blog.csdn.net/ANNILingMo/article/details/80698830
