二叉树的遍历本质 - 前序,中序,后序

本文详细介绍了二叉树的三种遍历方式:先序、中序和后序遍历,并通过实例展示了如何实现这些遍历过程。此外,文章还提供了一个简单的二叉树结构实现,帮助读者理解树的基本概念和操作。

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


// operatorTree.cpp
// 对树的操作

#include <iostream>
#include <cstdio>

// 二叉树表示法
typedef struct BiTNode
{
	int	data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

// 先序遍历
void preOrder(BiTNode *T)
{
	if (T == NULL) {
		return;
	}

	printf("%d ", T->data);

	preOrder(T->lchild);

	preOrder(T->rchild);

}

// 中序遍历
void inOrder(BiTNode *T)
{
	if (T == NULL) {
		return;
	}

	inOrder(T->lchild);

	printf("%d ", T->data);

	inOrder(T->rchild);
}

// 后序遍历
void postOrder(BiTNode *T)
{
	if (T == NULL) {
		return;
	}

	postOrder(T->lchild);

	postOrder(T->rchild);

	printf("%d ", T->data);
}

void traversalTree()
{
	BiTNode nodeA, nodeB, nodeC, nodeD, nodeE;

	memset(&nodeA, 0, sizeof(BiTNode));
	memset(&nodeB, 0, sizeof(BiTNode));
	memset(&nodeC, 0, sizeof(BiTNode));
	memset(&nodeD, 0, sizeof(BiTNode));
	memset(&nodeE, 0, sizeof(BiTNode));

	nodeA.data = 1;
	nodeB.data = 2;
	nodeC.data = 3;
	nodeD.data = 4;
	nodeE.data = 5;

	nodeA.lchild = &nodeB;
	nodeA.rchild = &nodeC;
	nodeB.lchild = &nodeD;
	nodeC.lchild = &nodeE;

	printf("preorder traversal.\n");
	preOrder(&nodeA);
	// 1 2 4 3 5
	printf("\n");

	printf("inorder traversal.\n");
	inOrder(&nodeA);
	// 4 2 1 5 3
	printf("\n");

	printf("postorder traversal.\n");
	postOrder(&nodeA);
	// 4 2 5 3 1
	printf("\n");
}

int main()
{
	traversalTree();

	return 0;
}

<think>我们首先需要明确用户的需求:用户希望了解如何在Python中实现二叉树前序、中后序遍历。根据提供的引用内容,我们已经有了一些基础代码,特别是中遍历的递归实现和栈实现的提示,以及二叉树节点的定义。下面我们将分别介绍这三种遍历方式的递归实现和迭代实现(使用栈)。 二叉树节点的定义(引用[2][^2]和[3][^3]): ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right ``` 遍历方式: 1. 前序遍历:根节点 -> 左子树 -> 右子树 2. 中遍历:左子树 -> 根节点 -> 右子树 3. 后序遍历:左子树 -> 右子树 -> 根节点 我们将分别给出递归和迭代的实现。 注意:引用[1]提供了中遍历的递归实现,我们可以参考并扩展。 步骤: 1. 递归实现:三种遍历的递归实现非常相似,只是访问根节点的时机不同。 2. 迭代实现:使用栈来模拟递归过程。 下面我们分别实现: 一、递归实现: 1. 前序遍历递归 2. 中遍历递归(引用[1]已给出) 3. 后序遍历递归 二、迭代实现(显式栈): 1. 前序遍历迭代 2. 中遍历迭代(引用[1]提到,但未给代码,我们补充) 3. 后序遍历迭代 另外,层遍历(广度优先)通常使用队列实现,但用户问题中未提及,我们暂不展开,但可以在相关问题中提出。 我们按照上述顺给出代码,并附上简要说明。 注意:在迭代实现中,前序和中相对简单,后序稍微复杂,但我们可以利用前序的变形然后反转得到,或者使用两个栈。 开始编写代码和说明:</think>### Python实现二叉树前序、中后序遍历 二叉树遍历是树结构的基础操作,核心在于访问节点的顺。以下是基于引用[2][^2]和[3][^3]的完整实现: --- #### **1. 二叉树节点定义** ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val # 节点值 self.left = left # 左子树指针 self.right = right # 右子树指针 ``` --- #### **2. 递归实现遍历** ##### **前序遍历**(根→左→右) ```python def preorder(root: TreeNode) -> list: if not root: return [] return [root.val] + preorder(root.left) + preorder(root.right) ``` **执行流程**: 1. 访问根节点 2. 递归遍历左子树 3. 递归遍历右子树 ##### **中遍历**(左→根→右)[^1] ```python def inorder(root: TreeNode) -> list: if not root: return [] return inorder(root.left) + [root.val] + inorder(root.right) ``` ##### **后序遍历**(左→右→根) ```python def postorder(root: TreeNode) -> list: if not root: return [] return postorder(root.left) + postorder(root.right) + [root.val] ``` --- #### **3. 迭代实现(显式栈)** ##### **前序遍历迭代版** ```python def preorder_iter(root: TreeNode) -> list: stack, res = [root], [] while stack: node = stack.pop() if node: res.append(node.val) # 先访问根 stack.append(node.right) # 右子先入栈(后出) stack.append(node.left) # 左子后入栈(先出) return res ``` ##### **中遍历迭代版**[^1] ```python def inorder_iter(root: TreeNode) -> list: stack, res = [], [] curr = root while curr or stack: while curr: # 深入左子树 stack.append(curr) curr = curr.left curr = stack.pop() res.append(curr.val) # 访问节点 curr = curr.right # 转向右子树 return res ``` ##### **后序遍历迭代版** ```python def postorder_iter(root: TreeNode) -> list: stack, res = [root], [] while stack: node = stack.pop() if node: res.append(node.val) stack.append(node.left) # 左子先入栈(后出) stack.append(node.right) # 右子后入栈(先出) return res[::-1] # 反转结果(左→右→根 → 根→右→左→反转) ``` --- #### **4. 复杂度分析** - **时间复杂度**:$O(n)$(所有节点访问一次) - **空间复杂度**: - 递归:$O(h)$($h$为树高,递归栈深度) - 迭代:$O(n)$(栈最大存储所有节点) --- ### 示例二叉树遍历结果 ```mermaid graph TD A(1) --> B(2) A --> C(3) B --> D(4) B --> E(5) ``` - **前序**:`[1, 2, 4, 5, 3]` - **中**:`[4, 2, 5, 1, 3]` - **后序**:`[4, 5, 2, 3, 1]` --- ### 关键点总结 1. **递归本质**:通过函数调用栈隐式实现回溯 2. **迭代核心**:用栈模拟递归过程,控制节点访问顺 3. **后序技巧**:利用`根→右→左`遍历后反转结果[^2]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值