1.2 树结构学习体会

难，不是我等凡夫俗子可以学会的。

困难点：对递归的理解不够透彻，一直转不过来。

解决办法：多看点代码。

2.PTA实验作业

题目一:6-4 jmu-ds-表达式树（25 分）

题目：

• 输入一行中缀表达式，转换一颗二叉表达式树，并求解.
• 表达式只包含+，-，*，/，（，）运算符，操作数只有一位，且为整数(有兴趣同学可以考虑负数小数，两位数做法)。按照先括号，再乘除，后加减的规则构造二叉树。
• 如图所示是"1+(2+3)*2-4/5"代数表达式对应二叉树，用对应的二叉树计算表达式的值。 转换二叉树如下：

思路：

建立表达式二叉树

定义栈 s 用来存储用运算的数字

定义字符栈 o p 用来存储数字运算符号

首先 将’#‘ 如栈op

当str不为空的时候 进行while

if 是数字

就建立一个树节点，将它赋值为str{i}的值，还要就左右孩子弄成NULL,  还要入栈

else 调动Precede

对它出现的运算符一一进行运作，

用swich

while  op的top不是#

创建新的树节点

赋予为op.top的值

在将栈里的后面两个值分别给左右孩子

/*计算表达式树*/

利用递归把所有字符转换成数字

while 若有树节点

就计算

4.PTA提交列表说明

题目二:6-1 jmu-ds-二叉树操作集（20 分）

本题要求用层次法创建二叉树，层次法输入序列是按树的从上到下从左到右的顺序形成，各层的空节点用字符 #表示

2.设计思路：

根据层次字符序列创建二叉树

定义一个队列q；

一个树 temp

if str是#

就直接ruturn

else 建立一个树节点

左右孩子为NULL；

将str【i】赋值给它

就节点入队列

while ！队列

出队列

分别判断字符串后两个是否为空

不是空：建立新节点，赋值

6-3 先序输出叶结点（15 分）

本题要求按照先序遍历的顺序输出给定二叉树的叶结点。

2.设计思路：

if ！BT 结束

当左右孩子多NULL时

就输出节点

总分

185

也就是2分

4.阅读代码

1. //huffmanCoding.c
2. #include <stdio.h>
3. #include <limits.h>
4. #include <string.h>
5. #include <stdlib.h>
6. #define N 6
7. typedef struct huffNode
8. {
9. unsigned int weight;   //权重
10. unsigned int lchild,rchild,parent;  //左右子节点和父节点
11. }HTNode,*HuffTree;
12. typedef char **HuffCode;
13. //找出数组中无父节点且权值最小的两个节点下标,分别用s1和s2保存
14. void select(const HuffTree &HT,int n,int &s1,int &s2);
15. //HT:哈夫曼树，HC:哈夫曼编码，w:构造哈夫曼树节点的权值，n:构造哈夫曼树节点的个数
16. void HuffmanCode(HuffTree &HT,HuffCode &HC,int *w,int n);
17. int main()
18. {
19. int i;
20. char key[N] = {‘0‘,‘A‘,‘B‘,‘C‘,‘D‘,‘E‘};//第0个元素保留不用
21. int w[N] = {0,1,2,4,5,6}; //第0个元素保留不用
22. HuffTree HT;
23. HuffCode HC;
24. HuffmanCode(HT,HC,w,N - 1);
25. for ( i = 1; i < N; i++ )
26. printf("%c:%s\n",key[i],HC[i]);
27. printf("\n");
28. return 0;
29. }
30. //找出数组中权值最小的两个节点下标,分别用s1和s2保存
31. void select(const HuffTree &HT,int n,int &s1,int &s2)
32. {
33. int i;
34. s1 = s2 = 0;
35. int min1 = INT_MAX;//最小值，INT_MAX在<limits.h>中定义的
36. int min2 = INT_MAX;//次小值
37. for ( i = 1; i <= n; ++i )
38. {
39. if ( HT[i].parent == 0 )
40. {//筛选没有父节点的最小和次小权值下标
41. if ( HT[i].weight < min1 )
42. {//如果比最小值小
43. min2 = min1;
44. s2 = s1;
45. min1 = HT[i].weight;
46. s1 = i;
47. }
48. else if ( (HT[i].weight >= min1) && (HT[i].weight < min2) )
49. {//如果大于等于最小值，且小于次小值
50. min2 = HT[i].weight;
51. s2 = i;
52. }
53. else
54. {//如果大于次小值，则什么都不做
55. ;
56. }
57. }
58. }
59. }
60. //HT:哈夫曼树，HC:哈夫曼编码，w:构造哈夫曼树节点的权值，n:构造哈夫曼树节点的个数
61. void HuffmanCode(HuffTree &HT,HuffCode &HC,int *w,int n)
62. {
63. int s1;
64. int s2;
65. int m = 2 * n - 1;       //容易知道n个节点构造的哈夫曼树是2n-1个节点
66. int i,c,f,j;
67. char *code;  //暂存编码的
68. HT = (HuffTree)malloc((m+1)*sizeof(HTNode));  //0单元未使用
69. for ( i = 1; i <= n; i++ )
70. HT[i] = {w[i],0,0,0};//初始化前n个节点(构造哈夫曼树的原始节点)
71. for ( i = n + 1; i <= m; i++ )
72. HT[i] = {0,0,0,0};  //初始化后n-1个节点
73. //构建哈夫曼树
74. for ( i = n + 1; i <= m; i++)
75. {
76. select(HT,i-1,s1,s2);//找出前i-1个节点中权值最小的节点下标
77. HT[s1].parent = i;
78. HT[s2].parent = i;
79. HT[i].lchild = s1;
80. HT[i].rchild = s2;
81. HT[i].weight = HT[s1].weight + HT[s2].weight;
82. }
83. //哈夫曼编码
84. HC = (char **)malloc((n)*sizeof(char *));
85. //暂存编码
86. code = (char *)malloc(n*sizeof(char));//使用了第0单元
87. for ( i = 1; i <= n; i++ )
88. {
89. for ( c = i, f = HT[c].parent, j = 0; f != 0; c = HT[c].parent, f = HT[c].parent,  j++ )
90. {//从叶子扫描到根
91. if ( HT[f].lchild == c )
92. {
93. code[j] = ‘0‘;
94. }
95. else if(HT[f].rchild == c)
96. {
97. code[j] = ‘1‘;
98. }
99. else
100. {//否则什么也不做
101. ;
102. }
103. }
104. code[j] = ‘\0‘;
105. HC[i] = (char *)malloc(strlen(code)*sizeof(char));
106. strcpy(HC[i],code);
107. }
108. }

原文地址：https://www.cnblogs.com/88888a/p/8995558.html