Python语言实现二叉树的前序、中序、后序和层序遍历

二叉树的遍历

二叉树的前序遍历

参考题目

LeetCode 144 二叉树的前序遍历

实现代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root):
        def preorder(root, res):
            if not root:
                return
            res.append(root.val)
            preorder(root.left, res)
            preorder(root.right, res)

        res = []
        preorder(root, res)
        return res

二叉树的中序遍历

参考题目

LeetCode 94 二叉树的中序遍历

实现代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root):
        def inorder(root, res):
            if not root:
                return
            inorder(root.left, res)
            res.append(root.val)
            inorder(root.right, res)

        res = []
        inorder(root, res)
        return res

二叉树的后序遍历

参考题目

LeetCode 145 二叉树的后序遍历

实现代码

# Definition for a binary tree node.
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def postorderTraversal(self, root):
        def postorder(root, res):
            if not root:
                return
            postorder(root.left, res)
            postorder(root.right, res)
            res.append(root.val)

        res = []
        postorder(root, res)
        return res

二叉树的层序遍历

参考题目

LeetCode 102. 二叉树的层序遍历

实现代码

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, val=0, left=None, right=None, level=0):
        self.val = val
        self.left = left
        self.right = right
        self.level = level
        
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        deque = collections.deque([root])
        root.level = 1
        levelList = [[] for i in range(2005)]
        maxLevel = 1
        
        while deque:
            node = deque.popleft()
            levelList[node.level].append(node.val)
            maxLevel = max(maxLevel, node.level)
            if node.left:
                node.left.level = node.level + 1
                deque.append(node.left)
            if node.right:
                node.right.level = node.level + 1
                deque.append(node.right)
        return levelList[1:maxLevel + 1]

二叉树已知中序、前序/后序 转 后序/前序

已知中序、后序转前序

参考文章

实现代码

# Definition for a binary tree node.
class TreeNode:
	def __init__(self, val=0, left=None, right=None):
		self.val = val
		self.left = left
		self.right = right

inOrder = [2, 1, 4, 3, 5]
postOrder = [2, 4, 5, 3, 1]

# 已知中序、后序打印前序
def preOrderPrint(r, start, end):
	if start > end:
		return None
	i = start
	while i < end and postOrder[r] != inOrder[i]:
		i += 1
	print(postOrder[r])
	preOrderPrint(r - (end - i + 1), start, i - 1)
	preOrderPrint(r - 1, i + 1, end)

# 返回建立好的二叉树的根节点root
root = preOrderPrint(4, 0, 4) # preOrderPrint(n - 1, 0, n - 1) n为节点数

已知中序、前序转后序

参考文章

实现代码

# Definition for a binary tree node.
class TreeNode:
	def __init__(self, val=0, left=None, right=None):
		self.val = val
		self.left = left
		self.right = right

inOrder = [2, 1, 4, 3, 5]
preOrder = [1, 2, 3, 4, 5]

# 已知中序、前序打印后序
def postOrderPrint(r, start, end):
	if start > end:
		return None
	i = start
	while i < end and preOrder[r] != inOrder[i]:
		i += 1
	postOrderPrint(r + 1, start, i - 1)
	postOrderPrint(r + (i - start) + 1, i + 1, end)
	print(preOrder[r])

# 返回建立好的二叉树的根节点root
root = postOrderPrint(0, 0, 4) # postOrderPrint(0, 0, n - 1) n为节点数