洛谷_P1305 新二叉树、UVA536 二叉树重建 Tree Recovery

1 洛谷_P1305 新二叉树

链接：洛谷_P1305 新二叉树

1.1 题目描述

输入一串二叉树，输出其前序遍历。

1.2 输入格式

第一行为二叉树的节点数 n。(1 <= n <= 26)

后面 n 行，每一个字母为节点，后两个字母分别为其左右儿子。特别地，数据保证第一行读入的节点必为根节点。

空节点用 * 表示

1.3 输出格式

二叉树的前序遍历。

1.4 样例

1.4.1 样例输入

6
abc
bdi
cj*
d**
i**
j**
1
2
3
4
5
6
7

1.4.2 样例输出

abdicj
1

1.5 思路

有2种方式：

• 链式存储
• 顺序存储

1.5.1 链式存储

• 我们创建一个节点结构体，包含data、left_child、right_child，以字符串形式一行一行读入数据，比如读入abc，则创建一个节点是将a存入到data，然后将bc分别存入left_child、right_child；第二次读入bdi，则是再创建一个新节点，同样将b存入data，将di存入left_child、right_child，以此类推

• 不过这种方法有一个致命的问题，每次存入新节点，都需要寻找新的节点的data的位置，比如第二次要查找b的位置，而我们链式存储只存储了根节点root，因此每次都需要查找data，这是非常耗费时间和性能的

• 如果数据按层次读入，第一次abc，第二次bdi，第三次cjh等等，则还比较好查找，但是如果不按层次，则非常困难，因此不太适用

1.5.2 顺序存储

顺序存储也有2种方法：

• 记住父节点或字节点
• 使用left_child和right_child分别记住左节点，右节点

这里使用第二种方式

• 每次输入的都是字符类型，我们可以每行读作一个字符串，然后单独访问字符串的每个字符，将字符减去一个a字符，如果输入的是abc，则a-'a'=0，则代表数字0，这样就可以存入左右子树数组，分别将bc存入left_child[0]和right_child[0]，这样就代表第一个节点的左右子树
• 同理，读入第二行数据bdi，则b-'b'=1，则分别将di存入left_child[1]和right_child[1]，以此类推
• 注意，如果是第一次读入，记得将根节点存入root
• 如果是空，即*，则只要存入*-'a'
• 存完后，使用前序遍历输出结果，只需要传入根节点，然后判断是否是*-'a'即可，如果不是则进行打印。
• 注意打印时，需要将数值返回，0则+a并转换成char类型，输出a；1则+a并转换成char类型，输出b

1.6 实现

#include
using namespace std;

int left_child[100], right_child[100];	//左右子树

void PreOrder(int val)	//前序遍历,递归
{
	if (val != '*' - 'a')	//非空才执行
	{
		cout << char(val + 'a');	//将值还原
		PreOrder(left_child[val]);
		PreOrder(right_child[val]);
	}
}
int main()
{
	string str;
	int num = 0, root = 0;
	cin >> num;
	
	for (int i = 0; i < num; i++)
	{
		cin >> str;	//逐行输入,以字符串的形式
		if (!i)		root = str[0] - 'a';	//根,只保存一次
		left_child[str[0] - 'a'] = str[1] - 'a';	//取出str的第[1]个字符存入左子树
		right_child[str[0] - 'a'] = str[2] - 'a';	//取出str的第[2]个字符存入右子树
	}
	PreOrder(root);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2 洛谷_UVA536 二叉树重建 Tree Recovery

链接：洛谷_UVA536 二叉树重建 Tree Recovery

2.1 题目描述

PDF

2.2 输入格式

2.3 输出格式

2.4 题面翻译

输入一棵二叉树的先序遍历和中序遍历序列，输出它的后序遍历序列。

2.5 样例

2.5.1 样例输入

DBACEGF ABCDEFG
BCAD CBAD
1
2

2.5.2 样例输出

ACBFGED
CDAB
1
2

2.6 思路

结果不需要存储，勾结过程中可以直接输出

2种方法：

• 取子串
• 传下标

2.6.1 取子串

• 找根，读取先序的第一个字符
• 根据中序的根来拆分左右子树
• 并构建左右子树
• 然后直接输出根

如此刚好得到树的后序遍历

缺点是需要取子串需要时间，如果字串很长，代价会很大

实现

#include
using namespace std;

//	取子串
string preorder, inorder;

void PostOrder(string pre, string in)
{
	if (pre.size() <= 0)	return;
	int len = 0;
	/*	1、遍历中序,以查找等于前序的第一个字符,返回位置
		while(in[len] != preorder[0])
		{
			len++;
		}
	*/
	
	//	2、直接调用函数，返回pre的第一个字符在in的位置
	len = in.find(pre[0]);
	PostOrder(pre.substr(1, len), in.substr(0, len));	//递归输出左子树
	PostOrder(pre.substr(len + 1), in.substr(len + 1));	//递归输出右子树
	cout << pre[0];	//输出根
}

int main()
{
	while (cin >> preorder >> inorder)
	{
		PostOrder(preorder, inorder);
		cout << endl;
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

2.6.2 传下标

将len1和len2为0传入

实现

//	传下标
string preorder, inorder;

void PostOrder(int len1, int len2, int num)
{
	if (num <= 0)	return;
	int len = inorder.find(preorder[len1]) - len2;
	PostOrder(len1 + 1, len2, len);	//递归输出左子树
	PostOrder(len1 + len + 1, len2 + len + 1, num - len - 1);	//递归输出右子树
	cout << preorder[len1];	//输出根
}

int main()
{
	while (cin >> preorder >> inorder)
	{
		int num = preorder.size();
		PostOrder(0, 0, num);
		cout << endl;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

• 1, len2 + len + 1, num - len - 1); //递归输出右子树
  cout << preorder[len1]; //输出根
  }

int main()
{
while (cin >> preorder >> inorder)
{
int num = preorder.size();
PostOrder(0, 0, num);
cout << endl;
}
return 0;
}

1