前序遍历、中序遍历、后续遍历的理解以及Python实现

1. 前序遍历

对于当前节点，先输出该节点，然后输出他的左孩子，最后输出他的右孩子。以上图为例，递归的过程如下：

（1）：输出 1，接着左孩子；
（2）：输出 2，接着左孩子；
（3）：输出 4，左孩子为空，再接着右孩子；
（4）：输出 6，左孩子为空，再接着右孩子；
（5）：输出 7，左右孩子都为空，此时 2 的左子树全部输出，2 的右子树为空，此时 1 的左子树全部输出，接着 1 的右子树；
（6）：输出 3，接着左孩子；
（7）：输出 5，左右孩子为空，此时 3 的左子树全部输出，3 的右子树为空，至此 1 的右子树全部输出，结束。

[1, 2, 4, 6, 7, 3, 5]

2. 中序遍历

对于当前结点，先输出它的左孩子，然后输出该结点，最后输出它的右孩子。以上图为例：

（1）：1-->2-->4，4 的左孩子为空，输出 4，接着右孩子；
（2）：6 的左孩子为空，输出 6，接着右孩子；
（3）：7 的左孩子为空，输出 7，右孩子也为空，此时 2 的左子树全部输出，输出 2，2 的右孩子为空，此时 1 的左子树全部输出，输出 1，接着 1 的右孩子；
（4）：3-->5，5 左孩子为空，输出 5，右孩子也为空，此时 3 的左子树全部输出，而 3 的右孩子为空，至此 1 的右子树全部输出，结束。

[4, 6, 7, 2, 1, 5, 3]

3. 后序遍历

对于当前结点，先输出它的左孩子，然后输出它的右孩子，最后输出该结点。依旧以上图为例：

（1）：1->2->4->6->7，7 无左孩子，也无右孩子，输出 7，此时 6 无左孩子，而 6 的右子树也全部输出，输出 6，此时 4 无左子树，而 4 的右子树全部输出，输出 4，此时 2 的左子树全部输出，且 2 无右子树，输出 2，此时 1 的左子树全部输出，接着转向右子树；
（2）：3->5，5 无左孩子，也无右孩子，输出 5，此时 3 的左子树全部输出，且 3 无右孩子，输出 3，此时 1 的右子树全部输出，输出 1，结束。

[7, 6, 4, 2, 5, 3, 1]

Python 实现：

• 在此之前，我们先创建一颗树

   class BinaryTree:
   	def __init__(self, root):
   		self.root= root
   		self.left = None
   		self.right = None
   	
   	def get(self):
   		return self.root
   	
   	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
  

  给二叉树赋值：

   btree = BinaryTree(1)
   btree.setLeft(BinaryTree(2))
   btree.setRight(BinaryTree(3))
   btree.getLeft().setLeft(BinaryTree(4))
   btree.getLeft().setRight(BinaryTree(None))
   btree.getLeft().getLeft().setLeft(BinaryTree(None))
   btree.getLeft().getLeft().setRight(BinaryTree(6))
   btree.getLeft().getLeft().getRight().setLeft(BinaryTree(None))
   btree.getLeft().getLeft().getRight().setRight(BinaryTree(7))
   btree.getRight().setLeft(BinaryTree(5))
   btree.getRight().setRight(BinaryTree(None))
  

• 前序遍历 Python实现

   def pre_order(current_root, res = []):
   	if current_root == None:
   		return res
   	
   	res.append(current_root.root)
   	pre_order(current_root.left, res)
   	pre_order(current_root.right, res)
   	return res
  
   print(pre_order(btree))
  
   [1, 2, 4, None, 6, None, 7, None, 3, 5, None]
  

• 中序遍历 Python实现

   def mid_order(current_root, res=[]):
   	if current_root == None:
   		return res
   	
   	mid_order(current_root.left, res)
   	res.append(current_root.root)
   	mid_order(current_root.right, res)
   	return res
  
   print(mid_order(btree))
   
   [None, 4, None, 6, 7, 2, None, 1, 5, 3, None]
  

• 后序遍历 Python实现

   def post_order(current_root, res=[]):
   	if current_root == None:
   		return res
   	
   	post_order(current_root.left, res)
   	post_order(current_root.right, res)
   	res.append(current_root.root)
   	return res
  
   print(post_order(btree))
   
   [None, None, 7, 6, 4, None, 2, 5, None, 3, 1]
  

• Leetcode 中的题
  - 94. 二叉树的中序遍历

   示例:
  
   输入: [1,null,2,3]
   	1
   	 \
   	 2
   	/
     3
   输出: [1,3,2] 
  
   class Solution(object):
   	def inorderTraversal(self, root):
  
   		def dfs(root, res = []):
       		if root == None:
           	return res
  
       		dfs(root.left, res)
       		res.append(root.val)
       		dfs(root.right, res)
  
       		return res
  
   	output = dfs(root)
   	return output