树(6)——树的前中后序遍历

一、前言

首先，我们要知道树的前中后序遍历顺序：
前序遍历： root、left、right
中序遍历：left、root、right
后序遍历：left、right、root
常见的实现方法分为递归解法和迭代解法，一下主要内容即将从这两方面进行记录。
leetcode上对应题目：
144.二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历

二、主要内容

这块首先记录前中后序的递归解法，然后记录前中后序的迭代解法。
递归解法：

# 前序遍历
class Solution:
	def preorderTraversal(self, root: TreeNode) -> List[int]:
		res = list()
		self.PreOrder(self,root,res)
		return res
	def PreOrder(self,root,res):
		if not root:
			return res
		res.append(root.val)
		self.PreOrder(root.left,res)
		self.PreOrder(root.right,res)

# 中序遍历
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:	
		res = list()
		self.InOrder(self,root,res)
		return res
	def InOrder(self,root,res):
		if not root:
			return res
		self.InOrder(root.left,res)
		res.append(root.val)
		self.InOrder(root.right,res)

# 后序遍历
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
    	res = list()
		self.PostOrder(self,root,res)
		return res
	def PostOrder(self,root,res):
		if not root:
			return res
		self.PostOrder(root.left,res)
		self.PostOrder(root.right,res)
		res.append(root.val)

迭代解法：

# 前序遍历
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root: return []
        results = list()
        stack = [root]
        while stack:                
            node = stack.pop()
            results.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)                            
        return results
# 中序遍历
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:return []
        res = []
        stack = []
        p = root
        while p or stack:
            while p:
                stack.append(p)
                p = p.left
            p = stack.pop()
            res.append(p.val)
            p = p.right
        return res
# 后序遍历
# 后序:left right root 
# 反过来即:root right left,得到反序，反向输出即可(可类比前序)
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:return []
        res = []
        stack = [root]
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return res[::-1]
    				 	

还有一种就是便于记忆和模板化的方法，''颜色标记法''

# 前序遍历
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        WHITE,GRAY = 0,1
        res = []
        stack = [(WHITE,root)]
        while stack:
            color,node = stack.pop()
            if not node:
                continue
            if color == WHITE:
                stack.append((WHITE,node.right))
                stack.append((WHITE,node.left))
                stack.append((GRAY,node))
            else:
                res.append(node.val)
        return res

# 中序遍历
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        GRAY,WHITE = 1,0
        res = []
        stack = [(WHITE,root)]
        while stack:
            color,node = stack.pop()
            if not node:
                continue
            if color == WHITE:
                stack.append((WHITE,node.right))
                stack.append((GRAY,node))
                stack.append((WHITE,node.left))
            else:
                res.append(node.val)
        return res
# 后序遍历
# 后序:left right root 
# 反过来即:root right left,得到反序，反向输出即可(可类比前序)
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        GRAY,WHITE = 1,0
        res = []
        stack = [(WHITE,root)]
        while stack:
            color,node = stack.pop()
            if not node:
                continue
            if color == WHITE:
            	stack.append((GRAY,node))
                stack.append((WHITE,node.right))
                stack.append((WHITE,node.left))
            else:
                res.append(node.val)
        return res

三、小结

以上主要从递归和迭代两方面记录实现了二叉树的前中后序遍历，其中还有一种便于记忆的"颜色标记法"，比较巧妙。