@TOC
第三章 数据结构
栈
例1. 括号匹配
例2. 计算简单表达式
哈夫曼树
哈夫曼树的定义
在含有N个带权叶子结点的二叉树中，其中带权路径长度（WPL）最小的二叉树称为哈夫曼树，也成为最优二叉树。
构造哈夫曼树的算法描述如下：
给定N个权值分别为w1, w2, …, Wn的节点。
（1）将这N个结点分别作为N棵树仅含一个结点的二叉树，构成森林F.
（2）构造一个新节点，并从F中选取两棵根结点权值最小的树作为新节点的左、右子树，并且将新节点的权值置为左、右子树上根结点的权值之和。
（3）从F中删除刚才选出的两棵树，同时将新得到的树加入F中。
（4）重复步骤2和3，直至F中只剩下一棵树为止。
在构造哈夫曼树的过程中使用小根堆可以在O(logn)的时间内取得n个元素中最小的数。借助STL中的优先队列，利用如下语句：1
2
3
4
5
6
7
8// 定义一个小根堆：
priority_queue<int, vector<int>, greater<int>> Q;
// 元素入队
Q.push(x;)
// 取堆顶元素
int a = Q.top();
// 元素出堆
Q.pop();
例3：
题目描述：哈夫曼树，第一行输入一个数n，表示叶节点的个数。需要用这些叶节点生成哈夫曼树，根据哈夫曼树的概念，这些节点有权值，即 weight，题目需要计算出所有节点与权值的乘积之和。
输入有多组数据：
第一行数据n；
第二行有n个数据
样例输入：
5
1 2 2 5 9
样例输出：
37
C++实现：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
using namespace std;
priority_queue<int, vector<int>, greater<int> > Q;
int main() {
int n;
while(scanf("%d", &n) != EOF) {
while(!Q.empty())
Q.pop();
// 排除堆非空对题目的影响
int m = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &m);
Q.push(m);
}
int ans = 0;
while(Q.size() > 1) {
int a = Q.top();
Q.pop();
int b = Q.top();
Q.pop();
ans += a + b;
Q.push(a + b);
// push这里每一层叠加的时候就把权值也计算进去了
}
printf("%d", ans);
}
return 0;
}
二叉树
二叉树节点的数据结构：1
2
3
4
5struct TNode {
struct TNode* lchild; // 左孩子
struct TNode* rchild; // 右孩子
ElemType data; // 数据域
} TNode, *BiTree;
1. 已知二叉树的前序遍历和中序遍历，求二叉树的后序遍历结果
题目： 根据前序和中序建立二叉树再输出结果。
C++编程结果：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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
using namespace std;
typedef struct TNode {
struct TNode* lchild; // 左孩子
struct TNode* rchild; // 右孩子
char data; // 数据域
} TNode, *BiTree;
BiTree CreatTree(char Pre[], char In[], int pl, int pr, int il, int ir) {
BiTree root = NULL;
root = new TNode();
root -> data = Pre[pl];
int index = 0;
for (index = il; In[index] != Pre[pl]; index++);
// 寻找前序第一个节点在中序中的位置
int lenl = index - il;
int lenr = ir - index;
if (lenl) {
root -> lchild = CreatTree(Pre, In, pl + 1, pl + lenl, il, il + lenl - 1);
} else {
root -> lchild = NULL;
}
if (lenr ) {
root -> rchild = CreatTree(Pre, In, pr - lenr + 1, pr, ir - lenr + 1, ir);
} else {
root -> rchild = NULL;
}
return root;
}
void PostOrder(BiTree T) {
if (T != NULL) {
PostOrder(T -> lchild);
PostOrder(T -> rchild);
printf("%c", T -> data);
}
}
void PostDeletTree(BiTree root) {
if(root != NULL) {
BiTree(root -> lchild);
BiTree(root -> rchild);
delete(root);
}
}
int main() {
char pre[26];
char in[26];
while(gets(pre) && gets(in)) {
int len = 0;
for(len = 0; pre[len] != '\0'; len++);
//建立二叉树
BiTree root = CreatTree(pre, in, 0, len - 1, 0, len - 1);
PostOrder(root); // 后序遍历二叉树
printf("\n");
PostDeletTree(root); // 释放建立二叉树时动态分配的内存
}
return 0;
}
2. 二叉排序树
题目： 输入一系列整数，建立二叉排序树，并对二叉排序树进行前序中序和后序遍历
输入：第一行包括一个整数n(0<n<100)，接下来的一行包括n个整数。提示： 输入可能包含重复数字，单输出的时候不用输出重复数字。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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
using namespace std;
typedef struct BNode {
struct BNode* lchild; // 左孩子
struct BNode* rchild; // 右孩子
int data; // 数据域
} BNode, *BiTree;
void PreOrder(BiTree T) {
if (T != NULL) {
printf("%d ", T -> data);
PreOrder(T -> lchild);
PreOrder(T -> rchild);
}
}
void InOrder(BiTree T) {
if (T != NULL) {
InOrder(T -> lchild);
printf("%d ", T -> data);
InOrder(T -> rchild);
}
}
void PostOrder(BiTree T) {
if (T != NULL) {
PostOrder(T -> lchild);
PostOrder(T -> rchild);
printf("%d ", T -> data);
}
}
BiTree BiSortTree(BiTree &root, int a) {
//建立二叉排序树的算法
if (root) {
if (a < root -> data)
root -> lchild = BiSortTree(root -> lchild, a);
else if(a > root -> data)
root -> rchild = BiSortTree(root -> rchild, a);
} else {
root = new BNode();
root -> data = a;
}
return root;
}
void PostDeletTree(BiTree root) {
// 后序删除二叉排序树
if(root != NULL) {
BiTree(root -> lchild);
BiTree(root -> rchild);
delete(root);
}
}
int main() {
int n = 0;
while(scanf("%d", &n) != EOF) {
BiTree T;
int x;
while(n--) {
scanf("%d", &x);
T = BiSortTree(T, x);
}
printf("前序遍历结果：");
PreOrder(T);
printf("\n中序遍历结果: ");
InOrder(T);
printf("\n后序遍历结果：");
PostOrder(T);
printf("\n");
PostDeletTree(T);
}
return 0;
}
3. 二叉排序树
题目： 开始是一个数n(0<n<20)表示有n个需要判断，n=0时结束，接下来一行是一个数字序列，序列长度小于10，包含0-9的数字，无重复，根据这个序列可以构造一个二叉排序树。接下来的n行有n个序列，每个序列的格式跟第一个一样，请判断这两个序列能否组成同一棵二叉树。
样例输入：
2
567432
543267
576342
样例输出：
YES
NO
思路：比较二叉排序树的遍历结果来判断两棵树是否一样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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
using namespace std;
typedef struct BNode {
struct BNode* lchild; // 左孩子
struct BNode* rchild; // 右孩子
char data; // 数据域
} BNode, *BiTree;
void PreOrder(BiTree T, char po[], int &index) {
if (T != NULL) {
po[index] = T -> data;
index++;
PreOrder(T -> lchild, po, index);
PreOrder(T -> rchild, po, index);
}
}
void InOrder(BiTree T, char po[], int &index) {
if (T != NULL) {
InOrder(T -> lchild, po, index);
po[index] = T -> data;
index++;
InOrder(T -> rchild, po, index);
}
}
BiTree BiSortTree(BiTree &root, int a) {
//建立二叉排序树的算法
if (root) {
if (a < root -> data)
root -> lchild = BiSortTree(root -> lchild, a);
else if(a > root -> data)
root -> rchild = BiSortTree(root -> rchild, a);
} else {
root = new BNode();
root -> data = a;
}
return root;
}
void PostDeletTree(BiTree root) {
// 后序删除二叉排序树
if(root != NULL) {
BiTree(root -> lchild);
BiTree(root -> rchild);
delete(root);
}
}
int main() {
int n = 0;
while(scanf("%d", &n) != EOF && n != 0) {
BiTree T = NULL;
char old[10] = {'\0'};
char pold[10] = {'\0'};
char iold[10] = {'\0'};
char str[10] = {'\0'};
char pstr[10] = {'\0'};
char istr[10] = {'\0'};
int index = 0;
scanf("%s", old);
int i = 0;
for (i = 0; old[i] != '\0'; i++)
T = BiSortTree(T, old[i]);
index = 0;
PreOrder(T, pold, index);
index = 0;
InOrder(T, iold, index);
PostDeletTree(T);
for (int j = 0; j < n; j++) {
// 将指针初始化为空很重要
BiTree NT = NULL;
for (int l = 0; l < n; l++) {
str[l] = '\0';
pstr[l] = '\0';
istr[l] = '\0';
}
scanf("%s", str);
for (int k = 0; str[k] != '\0'; k++)
NT = BiSortTree(NT, str[k]);
index = 0;
PreOrder(NT, pstr, index);
index = 0;
InOrder(NT, istr, index);
if (strcmp(pold, pstr) == 0 && strcmp(iold, istr) == 0)
printf("YES\n");
else
printf("NO\n");
PostDeletTree(NT);
}
printf("please input the number n: ");
}
return 0;
}