树的遍历(根据后序遍历中序遍历推出层序遍历)

对于二叉树的遍历,分为深度优先遍历与广度优先遍历,广度优先遍历有时又称作层序遍历。而深度优先遍历又分为前序遍历,中序遍历和后序遍历。三者之间的区别主要在于根结点的遍历顺序。前序遍历的顺序是根结点->左子树->右子树,中序遍历顺序是左子树->根结点->右子树,后序遍历顺序是左子树->右子树->根结点。现在给出树的后序遍历与中序遍历,要求写出该树的层序遍历。以下是pat上的例题:

给定一棵二叉树的后序遍历和中序遍历,请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。

输入格式:

输入第一行给出一个正整数N(<=30),是二叉树中结点的个数。第二行给出其后序遍历序列。第三行给出其中序遍历序列。数字间以空格分隔。

输出格式:

在一行中输出该树的层序遍历的序列。数字间以1个空格分隔,行首尾不得有多余空格。

输入样例:
7
2 3 1 5 7 6 4
1 2 3 4 5 6 7
输出样例:
4 1 6 3 5 7 2

分析:

树的后序遍历特点是最后一个遍历的永远是根结点,由样例很容易看到4即为该树的根结点。而中序遍历的特点是根结点的左边永远是根结点的左子树部分,右边永远是根结点的右子树部分。而树的每一个子树都可以作为新的根。因此二者结合起来很容易将整个树构建出来。以样例为例,首先可以从后序遍历确定4为根结点,然后对照着中序遍历找到4的中序位置为第4位,然后以4为界将树分为以左子树为根的树和以右子树为根的树。现在可以确定根的左子树与右子树的个数分别为m,n,而后序遍历先遍历左子树部分,因此可以确定左子树部分为第1~m位,右子树部分为m+1~m+n位,最后一位为根结点。而左子树部分最后一位即第n位为左子树部分的根即左子树,同理右子树也一样。由此我们只需建立一个树遍历的函数ergodic(int root, int start, int end, int index)即可。其中root为根结点,start与end为由该根结点所衍生出的所有子树的范围,index记录该树的位置。由后序遍历可知end即为根结点的位置,有start开始遍历中序,直到找到根结点在中序遍历中的位置i,在以i为界划分为(start,i-1)与(i+1,end)两部分,而root则为后序遍历中(start,end)中的end位置,即为root-end+i-1的位置。我们初始树的所有结点为-1,意味空值,因此最终搭建的树只需按顺序遍历所有有值部分即可。以下是代码:

#include<iostream>
#include<vector>
using namespace std;
vector<int>post, in, level(100000, -1);
int N;
void ergodic(int root, int start, int end, int index) {
	int i = start;
	if (start > end)
		return;
	while (i < end&&in[i] != post[root])
		i++;
	level[index] = post[root];
	//cout << root << start << end << i << endl;
	ergodic(root - 1 - end + i, start, i - 1, 2 * index + 1);
	ergodic(root - 1, i + 1, end, 2 * index + 2);
}
int main() {
	cin >> N;
	post.resize(N);
	in.resize(N);
	for (int i = 0; i < N; i++)
		cin >> post[i];
	for (int i = 0; i < N; i++)
		cin >> in[i];
	ergodic(N - 1, 0, N - 1, 0);
	for (int i = 0, cnt = 0; i < level.size(); i++) {
		if (level[i] != -1) {
			cout << level[i];
			cnt != N - 1 ? cout << ' ' : cout << endl;
			cnt++;
		}
	}
	return 0;
}

对于前序遍历也一样,因为前序遍历的特点和后序遍历的特点刚好相反,前序遍历第第一位总是根结点。根据两种遍历即可推出整棵树的结构,搭建完树的结构,任何遍历都会很方便。

### 回答1: 这道题需要用到二叉树后序遍历和中序遍历,然后再通过层序遍历输出列。具体步骤如下: 1. 根据后序遍历找到根节点,然后在中序遍历中找到根节点的位置,将中序遍历分成左子和右子两部分。 2. 对左子和右子分别进行递归,直到只剩下一个节点或者为空。 3. 对每个节点进行层序遍历,输出列。 代码实现如下: ``` #include <iostream> #include <queue> #include <unordered_map> using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; unordered_map<int, int> inorder_map; TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder, int in_start, int in_end, int post_start, int post_end) { if (in_start > in_end || post_start > post_end) { return NULL; } int root_val = postorder[post_end]; TreeNode* root = new TreeNode(root_val); int root_index = inorder_map[root_val]; int left_size = root_index - in_start; root->left = buildTree(inorder, postorder, in_start, root_index - 1, post_start, post_start + left_size - 1); root->right = buildTree(inorder, postorder, root_index + 1, in_end, post_start + left_size, post_end - 1); return root; } vector<int> levelOrder(TreeNode* root) { vector<int> res; if (!root) { return res; } queue<TreeNode*> q; q.push(root); while (!q.empty()) { int size = q.size(); for (int i = ; i < size; i++) { TreeNode* node = q.front(); q.pop(); res.push_back(node->val); if (node->left) { q.push(node->left); } if (node->right) { q.push(node->right); } } } return res; } vector<int> levelOrderTraversal(vector<int>& inorder, vector<int>& postorder) { int n = inorder.size(); for (int i = ; i < n; i++) { inorder_map[inorder[i]] = i; } TreeNode* root = buildTree(inorder, postorder, , n - 1, , n - 1); return levelOrder(root); } int main() { vector<int> inorder = {9, 3, 15, 20, 7}; vector<int> postorder = {9, 15, 7, 20, 3}; vector<int> res = levelOrderTraversal(inorder, postorder); for (int i = ; i < res.size(); i++) { cout << res[i] << " "; } cout << endl; return ; } ``` ### 回答2: 这是一道遍历的问题,需要先了解二叉树后序遍历、中序遍历层序遍历的规则。 后序遍历的顺是先遍历左子,再遍历右子,最后遍历根节点。 中序遍历的顺是先遍历左子,再遍历根节点,最后遍历右子层序遍历的顺是按照每一层从左到右依次遍历节点。 所以,我们可以根据题意,首先通过后序遍历和中序遍历获取到该二叉树的结构。接下来,我们可以借助队列来实现二叉树层序遍历。 具体思路如下: 1. 创建一个队列,在队列中先将根节点入队。 2. 当队列不为空时,执行以下步骤: a. 弹出队列中的最前面的节点,并将其输出。 b. 若该节点有左节点,则将其左节点入队。 c. 若该节点有右节点,则将其右节点入队。 3. 直到队列为空,输出所有节点即可。 综上,我们可以使用Python语言来实现以下代码: ``` from collections import deque def levelOrder(inorder, postorder): if len(inorder) == 0: return [] rootVal = postorder[-1] i = inorder.index(rootVal) root = TreeNode(rootVal) root.left = levelOrder(inorder[:i], postorder[:i]) root.right = levelOrder(inorder[i+1:], postorder[i:-1]) queue, res = deque(), [] queue.append(root) while queue: level = [] for i in range(len(queue)): node = queue.popleft() if node: level.append(node.val) queue.append(node.left) queue.append(node.right) if level: res.append(level) return res ``` 其中,TreeNode()为自定义的二叉树节点,inorder和postorder是输入的两个列表。最后返回的是二维列表,包含了二叉树层序遍历列。 ### 回答3: 首先,回想一下二叉树遍历方式,前序遍历是先访问根节点,然后按照左子、右子的顺递归遍历;中序遍历是先遍历左子,然后访问根节点,再递归遍历右子后序遍历则是先遍历左子、右子,然后访问根节点。层序遍历则是从上到下逐层遍历,按照从左至右的顺访问每个节点。 根据题目要,已知二叉树后序遍历和中序遍历,我们需要还原出它的层序遍历。 我们可以使用递归的方式构建二叉树,并同时生成它的层序遍历。由于层序遍历是按照层次遍历的,所以我们可以用一个队列来保存每一层的节点,从队列中取出节点时访问它的左右子节点,并将它们加入队列中,直到队列为空。 具体实现步骤如下: 1. 根据后序遍历和中序遍历还原出二叉树后序遍历中最后一个元素为根节点,根据这个元素在中序遍历中的位置可以分出左子和右子的中序遍历列,根据这两个列的长度可以知道左子和右子后序遍历列,在递归构建左右子。 2. 根据二叉树的根节点将它加入队列,并从队列中取出。 3. 访问根节点的左右子节点并将它们加入队列中。 4. 重复步骤2和3,直到队列为空。 最后,队列中的元素就是二叉树层序遍历列。 需要注意的是,在还原二叉树时,我们可以使用哈希表来存储中序遍历中每个节点的位置,这样可以减少元素查找的时间复杂度。同时,为了方便构建二叉树,我们可以用数组保存后序遍历列和中序遍历列。 实际实现时,我们可以定义一个名为“buildTree”的递归函数,该函数接受四个参数:后序遍历列、中序遍历列、每个节点在中序遍历列中的位置、根节点在后序遍历列中的位置。该函数返回以根节点为根的子。 代码如下: ```python class Solution: def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode: def build(inorder, postorder, in_start, in_end, post_start, post_end): if in_start > in_end: return None root = TreeNode(postorder[post_end]) root_idx = idx_map[root.val] left_size = root_idx - in_start root.left = build(inorder, postorder, in_start, root_idx - 1, post_start, post_start + left_size - 1) root.right = build(inorder, postorder, root_idx + 1, in_end, post_start + left_size, post_end - 1) return root n = len(inorder) idx_map = {val: idx for idx, val in enumerate(inorder)} return build(inorder, postorder, 0, n - 1, 0, n - 1) ``` 接下来是层序遍历的代码: ```python from collections import deque def levelOrder(root): if not root: return [] queue = deque([root]) res = [] while queue: level_size = len(queue) cur_level = [] for _ in range(level_size): node = queue.popleft() cur_level.append(node.val) if node.left: queue.append(node.left) if node.right: queue.append(node.right) res.append(cur_level) return res ``` 最终返回的res即为二叉树层序遍历列。 总结一下,本题的关键是如何把已知的后序遍历和中序遍历还原成二叉树,并把还原出的二叉树按照层次遍历输出。通过递归的方式构建二叉树,并使用队列实现层序遍历即可解决。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值