二叉树的四种遍历方式 (前序,中序,后序,层序遍历 python实现)

本文详细介绍了二叉树的四种基本遍历方法:前序、中序、后序及层序遍历,并通过Python代码实现。每种遍历方式的特点及应用场景也有所涉及。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

# -*- coding:utf-8 -*-
'''
题目描述
操作给定的二叉树,输出二叉树的三种遍历结果

前序遍历:根左右 8 6 5 7 10 9 11         第一位是根节点
中序遍历:左根右 5 6 7 8 9 10 11         中间一位是根节点
后续遍历:左右根 5 7 6 9 10 10 8         最后一位是根节点


层序遍历与上述三种略有不同,要采用队列的方式进行遍历,而不再是递归
层序遍历:上到下,左到右 8 6 10 5 7 9 11  第一位是根节点

方法 1. 根节点入队列
     2. while 判断队列不为空,则弹出第一个结点,访问,并将该结点的左右子孩子入队

输入描述:

二叉树
    	    8
    	   / \
    	  6   10
    	 / \  / \
    	5   7 9  11

'''
import Queue


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

class Solution(object):
    # 前序遍历:根左右
    def ProOrderTraverse(self, root):
        # write code here
        if not root:
            return

        print root.val
        self.ProOrderTraverse(root.left)
        self.ProOrderTraverse(root.right)

    # 中序遍历:左根右
    def inOrderTraverse(self, root):
        if not root:
            return

        self.inOrderTraverse(root.left)
        print root.val
        self.inOrderTraverse(root.right)


    # 后序遍历:左右根
    def PostOrderTraverse(self,root):
        if not root:
            return

        self.PostOrderTraverse(root.left)
        self.PostOrderTraverse(root.right)
        print root.val

    # 层序遍历:自上而下,同一层自左向右
    def LevelOrderTraverse(self, root):
        # 构造队列
        treequeue = Queue.Queue()

        if not root:
            return

        treequeue.put(root)
        while treequeue:
            root = treequeue.get()
            print root.val
            if root.left:
                treequeue.put(root.left)
            if root.right:
                treequeue.put(root.right)


pRoot1 = TreeNode(8)
pRoot2 = TreeNode(6)
pRoot3 = TreeNode(10)
pRoot4 = TreeNode(5)
pRoot5 = TreeNode(7)
pRoot6 = TreeNode(9)
pRoot7 = TreeNode(11)
pRoot1.left = pRoot2
pRoot1.right = pRoot3
pRoot2.left = pRoot4
pRoot2.right = pRoot5
pRoot3.left = pRoot6
pRoot3.right = pRoot7

if __name__ == '__main__':
    s = Solution()

    print '<--------------前序遍历-------------->'
    s.ProOrderTraverse(pRoot1)
    print '<--------------中序遍历-------------->'
    s.inOrderTraverse(pRoot1)
    print '<--------------后序遍历-------------->'
    s.PostOrderTraverse(pRoot1)
    print '<--------------层序遍历-------------->'
    s.LevelOrderTraverse(pRoot1)


### 二叉树前序、中后序遍历的例题与练习 以下是一些关于二叉树前序、中后序遍历的经典例题和练习,供学习参考。 #### 练习题 1:已知前序和中遍历,求后序遍历 已知一棵二叉树前序遍历为 `ABDHIEJCFKG`,中遍历为 `HDIBEJAFKCG`,请写出该二叉树后序遍历结果。 - **解答**: 根据前序遍历的第一个节点为根节点的特性,可以确定根节点为 `A`。在中遍历中,`A` 左边的部分为左子树,右边的部分为右子树。通过递归分析,最终得到后序遍历结果为 `HIDJEBKFGCA`[^2]。 ```python # 示例代码实现后序遍历 class TreeNode: def __init__(self, data): self.data = data self.left = None self.right = None def build_tree(preorder, inorder): if not preorder or not inorder: return None root_val = preorder[0] root = TreeNode(root_val) root_index = inorder.index(root_val) root.left = build_tree(preorder[1:root_index + 1], inorder[:root_index]) root.right = build_tree(preorder[root_index + 1:], inorder[root_index + 1:]) return root def postorder_traversal(root): if root is None: return [] return postorder_traversal(root.left) + postorder_traversal(root.right) + [root.data] # 输入示例 preorder = ['A', 'B', 'D', 'H', 'I', 'E', 'J', 'C', 'F', 'K', 'G'] inorder = ['H', 'D', 'I', 'B', 'E', 'J', 'A', 'F', 'K', 'C', 'G'] root = build_tree(preorder, inorder) postorder_result = postorder_traversal(root) print("后序遍历结果:", postorder_result) ``` --- #### 练习题 2:根据先和中遍历还原二叉树 已知一棵二叉树的先遍历为 `EFHIGJK`,中遍历为 `HFIEJKG`,请还原该二叉树并写出其后序遍历结果。 - **解答**: 通过先遍历的第一个节点 `E` 确定根节点,在中遍历中找到 `E` 的位置,分割左右子树。递归构建二叉树后,得到后序遍历结果为 `HIFJKEG`[^3]。 ```python # 示例代码实现和中还原二叉树 def build_tree_from_pre_in(preorder, inorder): if not preorder or not inorder: return None root_val = preorder[0] root = TreeNode(root_val) root_index = inorder.index(root_val) root.left = build_tree_from_pre_in(preorder[1:root_index + 1], inorder[:root_index]) root.right = build_tree_from_pre_in(preorder[root_index + 1:], inorder[root_index + 1:]) return root def postorder_traversal(root): if root is None: return [] return postorder_traversal(root.left) + postorder_traversal(root.right) + [root.data] # 输入示例 preorder = ['E', 'F', 'H', 'I', 'G', 'J', 'K'] inorder = ['H', 'F', 'I', 'E', 'J', 'K', 'G'] root = build_tree_from_pre_in(preorder, inorder) postorder_result = postorder_traversal(root) print("后序遍历结果:", postorder_result) ``` --- #### 练习题 3:完全二叉树层序遍历 已知一棵完全二叉树的高度为 4,第一层有 1 个节点,第二层有 2 个节点,第三层有 4 个节点,第四层有 8 个节点。若该二叉树前序遍历为 `EACBDGF`,请写出其中遍历后序遍历结果。 - **解答**: 根据前序遍历和完全二叉树的性质,可以逐步还原二叉树结构。最终得到中遍历为 `ABCEDGF`,后序遍历为 `CBEGAFD`[^3]。 ```python # 示例代码实现完全二叉树遍历 from collections import deque def level_order_traversal(root): if not root: return [] queue = deque([root]) result = [] while queue: node = queue.popleft() result.append(node.data) if node.left: queue.append(node.left) if node.right: queue.append(node.right) return result # 构建完全二叉树(假设已知前序遍历) preorder = ['E', 'A', 'C', 'B', 'D', 'G', 'F'] inorder = ['A', 'B', 'C', 'D', 'E', 'F', 'G'] root = build_tree(preorder, inorder) # 层序遍历 level_order_result = level_order_traversal(root) print("层序遍历结果:", level_order_result) # 中后序遍历 inorder_result = inorder_traversal(root) postorder_result = postorder_traversal(root) print("中遍历结果:", inorder_result) print("后序遍历结果:", postorder_result) ``` --- #### 练习题 4:表达式树的遍历 已知一棵表达式树的前序遍历为 `-+a*bc/de`,中遍历为 `a+b*c-d/e`,请写出该表达式树的后序遍历结果。 - **解答**: 根据前序遍历和中遍历的特点,可以逐步还原表达式树的结构。最终得到后序遍历结果为 `abc*+de/-`[^2]。 ```python # 示例代码实现表达式树的遍历 class ExpressionTreeNode: def __init__(self, data): self.data = data self.left = None self.right = None def build_expression_tree(preorder, inorder): if not preorder or not inorder: return None root_val = preorder[0] root = ExpressionTreeNode(root_val) root_index = inorder.index(root_val) root.left = build_expression_tree(preorder[1:root_index + 1], inorder[:root_index]) root.right = build_expression_tree(preorder[root_index + 1:], inorder[root_index + 1:]) return root def postorder_traversal(root): if root is None: return [] return postorder_traversal(root.left) + postorder_traversal(root.right) + [root.data] # 输入示例 preorder = ['-','+','a','*','b','c','/','d','e'] inorder = ['a','+','b','*','c','-','d','/','e'] root = build_expression_tree(preorder, inorder) postorder_result = postorder_traversal(root) print("后序遍历结果:", ''.join(postorder_result)) ``` ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值