【PAT甲级】1102 Invert a Binary Tree (25分)

本文详细解析了一道关于二叉树节点信息处理的问题,重点在于理解如何通过节点的左右孩子信息进行节点反转,并实现中序遍历与层次遍历。文章分享了解题过程,包括数据结构设计、读取输入、寻找根节点、以及遍历算法的实现。

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

解题过程的小记录,如有错误欢迎指出。

难度:三星(弄懂前两个关于二叉树的题这题就很顺了,不过看完题解才知道这道题原来是要将每个结点的左右孩子反转orz,误打误撞也对了)

题目分析

给出一堆结点信息(结点个数,它指向的左孩子和右孩子的序号)

注意点

  1. 数据域就是给出信息的下标0~n-1
    2. 这题的中序遍历和层次遍历都是先右后左,和平时的不太一样 (是因为你题目没看懂啊喂(#`O′))

我的解题过程

思路

  1. 先开一个类型为node*的vector数组存储所有结点信息(data,左右孩子初始化为NULL)
  2. 读入题设信息(需要注意的是,如果中序遍历和层次遍历按照平常的写法不变,本题左边读入的右孩子,右边读入的是左孩子),如果有孩子的使其通过下标指向vector中的node*
  3. 然后就是常规操作的中序遍历和层次遍历

bug

代码

#include<iostream>
#include<vector>
#include<string>
#include<queue>

using namespace std;

int n, incnt = 0, layercnt = 0;

struct node {
	int data;
	node *lchild, *rchild;
};

node* create(int data) {
	node *root = new node;//****一定要new
	root->data = data;
	root->lchild = NULL;
	root->rchild = NULL;
	return root;
}

void inorder(node *root) {//中序遍历
	if (root == NULL) return;
	inorder(root->lchild);
	printf("%d", root->data);
	incnt++;
	if (incnt != n) printf(" ");
	inorder(root->rchild);
}

void layerorder(node *root) {//层次遍历
	if (root == NULL) return;
	queue<node*> q;//***注意队列的类型
	q.push(root);
	while (!q.empty()) {
		node *top = q.front();
		q.pop();
		printf("%d", top->data);
		layercnt++;
		if (layercnt != n) printf(" ");
		if (top->lchild != NULL) q.push(top->lchild);
		if (top->rchild != NULL) q.push(top->rchild);
	}
}

int main()
{
	cin >> n;
	vector<node*> nodes(n);
	vector<int> hashTable(n, 0);
	for (int i = 0; i < n; i++) {
		nodes[i] = create(i);
	}
	for (int i = 0; i < n; i++) {
		string right, left;
		cin >> right >> left;
		if (right != "-") {
			hashTable[stoi(right)] = 1;
			nodes[i]->rchild = nodes[stoi(right)];
		}
		if (left != "-") {
			hashTable[stoi(left)] = 1;
			nodes[i]->lchild = nodes[stoi(left)];
		}
	}
	int head = 0;
	for (head; head < n; head++) {//找到跟结点
		if (hashTable[head] == 0)  break;
	}
	layerorder(nodes[head]);
	printf("\n");
	inorder(nodes[head]);
    return 0;
}

dalao的代码

全部代码因版权原因不放出来,大家可以自行去柳神博客购买或者参考晴神的上机笔记~

借鉴点

本题看自己的即可

<think>好的,我需要解释用户提供的这个反转二叉树的函数。首先,我得理解这个函数的结构和作用。函数名为invert_tree,参数是root,看起来是一个二叉树的节点。 首先,函数检查root是否存在(if root:),如果存在,就交换它的左右子节点。这里用到了递归,因为对左右子节点也调用了invert_tree。最后返回root。整个过程应该是将每个节点的左右子树都交换,从而反转整个二叉树。 接下来,我需要考虑如何逐步解释这个函数。可能需要从递归的基本思想入手,解释基线条件和递归步骤。基线条件是当root为空时,直接返回。递归步骤则是先处理左右子树,再交换它们的位置。 另外,要说明这个算法的时间复杂度和空间复杂度。因为是遍历每个节点一次,时间复杂度应该是O(n),n是节点数量。空间复杂度取决于递归的深度,最坏情况下(树完全不平衡)是O(n),平均情况下(平衡树)是O(log n)。 还需要提到应用场景,比如镜像二叉树、某些算法问题中的需求,比如判断对称二叉树可能需要先反转再比较。 可能还需要对比其他实现方式,比如使用迭代法(队列或栈)来反转二叉树,但用户提供的代码是递归实现,所以重点在递归上。 要注意代码中的交换操作是在递归调用之后还是之前。这里代码是root.left和root.right别赋值为反转后的右子树和左子树,所以是后序遍历,先处理子节点再交换。这样是否正确?是的,因为先递归反转左右子树,再交换它们的引用,这样整个树就被反转了。 可能还要给出一个例子,比如输入一个树的结构,然后展示反转后的结果,帮助用户理解。 此外,需要指出可能的错误情况,比如如果节点没有left或right属性是否会出错,但函数中只要root非空就会执行交换,所以假设节点结构正确,有left和right属性。如果传入的root节点不符合这个结构,可能会抛出错误,但函数本身没有处理这些情况,属于前提条件。 最后,总结这个函数的用途和实现方法,强调递归的简洁性和效率。</think>```markdown # 二叉树反转函数解析:递归实现详解 ## 一、函数定义与核心逻辑 ```python def invert_tree(root): if root: # 基线条件:节点存在时操作 # 后序遍历递归 + 交换左右子树 root.left, root.right = invert_tree(root.right), invert_tree(root.left) return root # 返回当前子树的新根节点 ``` ## 二、算法执行流程解析 ### 2.1 递归过程解 1. **叶子节点**:直接交换左右空指针(实际无变化) 2. **单子树节点**: ``` 1 1 / \ => \ 2 ∅ 2 ``` 3. **完整子树节点**: ``` 1 1 / \ / \ 2 3 => 3 2 ``` ### 2.2 时间复杂度析 | 情况 | 时间复杂度 | 空间复杂度 | |-------------|----------|----------| | 平衡二叉树 | $O(n)$ | $O(\log n)$ | | 链状结构 | $O(n)$ | $O(n)$ | ## 三、执行示例演示 ### 原始树结构: ``` 4 / \ 2 7 / \ / \ 1 3 6 9 ``` ### 执行过程: 1. 反转左子树(2为根) - 反转1→保持 - 反转3→保持 - 交换1和3的父节点指针 2. 反转右子树(7为根) - 反转6→保持 - 反转9→保持 - 交换6和9的父节点指针 3. 交换根节点4的左右子树指针 ### 最终结果: ``` 4 / \ 7 2 / \ / \ 9 6 3 1 ``` ## 四、常见问题解答 ### Q1:如何处理空节点? - 函数通过`if root`判断自动过滤空节点,递归到叶子节点时自然终止 ### Q2:能否用迭代法实现? **层序遍历实现示例**: ```python def invert_tree_iterative(root): stack = [root] while stack: node = stack.pop() if node: node.left, node.right = node.right, node.left stack.append(node.left) stack.append(node.right) return root ``` ### Q3:算法应用场景 1. 创建镜像二叉树 2. 判断对称二叉树(需比较原树与镜像树) 3. 图形渲染中的场景翻转 4. 某些二叉树算法题的基础操作 ## 五、代码健壮性析 ### 5.1 优势特性 - 自动处理空指针 - 内存效率高(原地修改) - 代码简洁直观 ### 5.2 潜在风险 - 节点必须具有left/right属性 - 超深递归可能引发栈溢出(Python默认递归深度约1000层) ## 六、算法变体扩展 ### 带返回值统计的版本 ```python def invert_tree_with_count(root): if not root: return 0 left_count = invert_tree_with_count(root.left) right_count = invert_tree_with_count(root.right) root.left, root.right = root.right, root.left return left_count + right_count + 1 ``` 该实现通过后序遍历统计反转操作涉及的节点总数,展示了如何在基础算法上添加附加功能。 通过这种递归实现,我们以$O(n)$时间复杂度高效完成了二叉树的反转操作,这种模式也是处理树形结构的经典范式。 ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值