用两个模板(递归法和迭代法)完成二叉树的四种遍历方式

二叉树的基本概念

首先二叉树是一棵树，树是一种数据结构，是由n个结点组成的一个集合。由于二叉树的各种性质，我们常用的树是二叉树，二叉树就是度为2的树。结点拥有子树的数目就称为结点的度，对一颗树而言，树的度为所有结点的度中，最大的那个度。
树的深度： 树的层次数
叶子结点（终端结点）： 度为0的结点
满二叉树： 只有最后一层有叶子结点，且倒数第二层结点的度全为2。

图是网上找的，侵权删。
完全二叉树： 只有最后一层和倒数第二层结点的度小于2。且最后一层的结点从左开始连续排列。

二叉树的性质：

1. 第i层上的结点数最多为2^i-1。
2. 深度为k的二叉树结点最多为2^k-1。
3. 包含n个结点的二叉树的深度至少为log₂(n+1)。
4. 叶子结点的个数等于度为2的结点数+1。

123三个性质相互联系，记下第1个性质，23性质就不难，这里主要讲讲第4个性质。
由于二叉树的结点的度数不大于2，那么可以得到等式1：
结点总数n = 0度结点数n0 + 1度结点数n1 + 2 度结点数n2
即n = n0 + n1 + n2 -------------式(1)
由于0度结点没有孩子结点，1度结点有一个孩子，2度结点有两个孩子，且只有根结点不是其他结点的孩子，总结点数等于孩子结点数+根结点数（难理解的话拿上面那张图，自己算一遍），所以可以得到等式2：
n = n1 + 2*n2 + 1 ---------------式(2)
由式1和式2可得，n0 = n2 + 1。

对二叉树有了基本概念之后，接着讲讲非常重要的二叉树遍历，二叉树的遍历方式主要分为四种：前序遍历，中序遍历，后序遍历和层序遍历。前中后遍历可以理解为遍历父节点的顺序，前序是先遍历父节点再左右结点，中序是先左再父再右，后序是先遍历左右结点，最后遍历父节点，三种遍历方式都需要用到栈，可以用递归或者迭代的方法实现，递归用的是系统栈，迭代用的是自己维护的栈，迭代的速度快一点，下面会给出两个模板分别实现这两种方法。层序遍历是从上到下，从左到右遍历所有结点，层序遍历使用的是BFS的方法，用到了队列。

以上图为例，
前序遍历的结果：[1 2 4 8 9 5 10 2 6 7]
中序遍历的结果：[8 4 9 2 10 5 1 6 2 7]
后序遍历的结果：[8 9 4 10 5 2 6 2 7 1]
层序遍历的结果：[[1], [2 2], [4 5 6 7], [8 9 10]]
力扣上的题目：
144.二叉树的前序遍历
94.二叉树的中序遍历
145.二叉树的后序遍历
101.二叉树的层序遍历
python中树结点的定义：

class TreeNode:
	def __init__(sefl, x):
		self.val = x
		self.left = None
		self.right = None

递归法模板

递归法的写法非常简单。

前序遍历

def preorderTraversal(root):
	if not root:
		return []
	return [root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right)

中序遍历

def inorderTraversal(root):
	if not root:
		return []
	return self.inorderTraversal(root.left) + [root.val] + self.inorderTraversal(root.right)

后序遍历

def postorderTraversal(root):
	if not root:
		return []
	return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]

迭代法模板

接下来是最重要的部分。迭代法的实现方法有几种，为了统一模板，我们加入标记WHITE和BLACK，白色表示没有被访问，黑色表示已经访问过了。如果当前结点是新结点，就将该结点压栈，设为已访问(BALCK)，并将其左右子结点压栈，设为未访问(WHITE)；如果当前结点已访问，直接加入结果。使用该模板，只要将压栈顺序改一下，就可以完成前中后三种遍历方式。

前序遍历

def preorderTraversal(root):
	WHITE, BLACK = 0, 1
	stack = [(WHITE, root)]
	res = []
	
	while stack:
		mask, cur= stack.pop()
		
		# 如果推出来的结点为空，跳过
		if not cur: continue
		
		# 如果推出来的结点是新结点，将该结点压栈并设为已访问，且将其左右子结点压栈，设为未访问
		# 如果结点已访问，直接加入结果中
		if mask == WHITE：
			# 由于栈先入后出的特点，所以入栈顺序要反着来
			stack.append((WHITE, cur.right))
			stack.append((WHITE, cur.left))
			stack.append((BLACK, cur))
		else:
			res.append(cur.val)
	return res

中序遍历

def inorderTraversal(root):
	WHITE, BLACK = 0, 1
	stack = [(WHITE, root)]
	res = []
	
	while stack:
		mask, cur= stack.pop()
		
		# 如果推出来的结点为空，跳过
		if not cur: continue
		
		# 如果推出来的结点是新结点，将该结点压栈并设为已访问，且将其左右子结点压栈，设为未访问
		# 如果结点已访问，直接加入结果中
		if mask == WHITE：
			# 由于栈先入后出的特点，所以入栈顺序要反着来
			stack.append((WHITE, cur.right))
			stack.append((BLACK, cur))
			stack.append((WHITE, cur.left))
		else:
			res.append(cur.val)
	return res

后序遍历

def postorderTraversal(root):
	WHITE, BLACK = 0, 1
	stack = [(WHITE, root)]
	res = []
	
	while stack:
		# 先入后出
		mask, cur= stack.pop()
		
		# 如果推出来的结点为空，跳过
		if not cur: continue
		
		# 如果推出来的结点是新结点，将该结点压栈并设为已访问，且将其左右子结点压栈，设为未访问
		# 如果结点已访问，直接加入结果中
		if mask == WHITE：
			# 由于栈先入后出的特点，所以入栈顺序要反着来
			stack.append((BLACK, cur))
			stack.append((WHITE, cur.right))
			stack.append((WHITE, cur.left))
		else:
			res.append(cur.val)
	return res

可以看到三种遍历只要改一下压栈顺序就行了，我只能说，妙啊。
参考：颜色标记法

层序遍历（BFS）

层序遍历个人觉得更好理解，有两种要求，第一种是层序遍历完把结果放在一个列表中，第二种是把每一层的结果分别放在一个列表中，然后将这些列表放在一起形成二维列表。

以上图为例，第一种层序遍历的结果是[1 2 2 4 5 6 7 8 9 10]，第二种层序遍历的结果是[[1], [2 2], [4 5 6 7], [8 9 10]]。
先看第一种，就是使用朴实无华的广度优先算法（BFS）：

def levelOrder(root):
	if not root:
		return []
	queue = [root]
	res = []

	while queue:
		# 先入先出
		cur = queue.pop(0)
		res.append(cur.val)
		if cur.left:
			queue.append(cur.left)
		if cur.right:
			queue.append(cur.right)
	return res

第二种层序遍历，只要在第一种的基础上分层存储：

def levelOrder(root):
	if not root:
		return []
	queue = [root]
	res = []

	while queue:
		# 分层存储
		level = []
		length = len(queue)
		for i in range(length):
			# 先入先出
			cur = queue.pop(0)
			level.append(cur.val)
			if cur.left:
				queue.append(cur.left)
			if cur.right:
				queue.append(cur.right)

		# 遍历完一层就加到最终结果中
		res.append(level)
	return res

综上，二叉树的遍历涉及到队列，栈，递归，迭代，广度优先算法(BFS)，深度优先算法(DFS)等知识，理解了以后对做后面的算法题有很大的帮助。