练习46

 

1. /**********************************************************************************
3.   46. 设有一个字符串，长度小于 100，且全部以英文字母组成。对字串中的每个字
4.  母可用 0,1,2 三个数字进行编码，且数字可以重复使用。
5.  程序要求：(1) 输入字符串，并能判断输入是否有错；
6.            (2) 输出对应的编码表及码长，要求字串的编码总长度为最短；
7.            (3) 根据上述编码表，给出一些编码，然后求出其原字符串。
8.  例如：输入的字符为:ABCBAAADDEF
9.      其对应的编码表为：
10.          A:   2                B:  10
11.          C:  11                D:  12
12.          E:  00                F:  01
13.  对应的编码为：210111022212120001       总码长为：18
14.  根据该编码，给出编码:010001121110222   则输出字串:FEFDCBAAA.
16.   *******************************************************************************/
18. #include <stdio.h>
19. #include <malloc.h>
21. //英文字母的个数
22. #define LETTER_NUM 26
24. //编码树节点
25. typedef struct
26. {
27.     int weight;
28.     int parent;
29.     int child0;
30.     int child1;
31.     int child2;
32. }   TreeNode;
34. char *Letters;//字母
35. int *Weights;//权值(字母使用的个数)
36. int LetterNum;//字母个数
38. TreeNode *Tree;//编码树节点集(数组指针)
39. int NodeNum;//节点个数
40. int CodeLen;//码长
42. //统计字母个数
43. int CountLetter(char *str)
44. {
45.     int i,k;
46.     static int Counter[LETTER_NUM];
48.     LetterNum = 0;
49.     for(i=0; str[i] != '/0'; i++)
50.     {
51.         //如果含有非字母,返回错误
52.         if(str[i]<0x61 || str[i]>0x7A)
53.             return 0;
54.         if(Counter[str[i]-0x61] == 0)
55.             LetterNum ++;
56.         Counter[str[i]-0x61] ++;
57.     }
58.     //为字母和统计个数分配空间
59.     Letters = (char*)malloc(LetterNum*sizeof(char));
60.     Weights = (int*)malloc(LetterNum*sizeof(int));
61.     for(i=0,k=0; i<LETTER_NUM; i++)
62.     {
63.         if(Counter[i] > 0)
64.         {
65.             Letters[k] = (char)(i+0x61);
66.             Weights[k++] = Counter[i];
67.         }
68.     }
69.     return 1;
70. }
72. //创建编码树
73. void CreateTree()
74. {
75.     int i,j;
76.     int min1,min2,min3;
78.     NodeNum = LetterNum + LetterNum/2;
79.     Tree = (TreeNode*)malloc(NodeNum*sizeof(TreeNode));
80.     for(i=0; i<LetterNum; i++)
81.     {
82.         Tree[i].weight = Weights[i];
83.         Tree[i].parent = -1;
84.         Tree[i].child0 = -1;
85.         Tree[i].child1 = -1;
86.         Tree[i].child2 = -1;
87.     }
88.     if(LetterNum % 2 == 0)
89.     {
90.         min1 = 0;
91.         min2 = 1;
92.         if(Tree[min1].weight > Tree[min2].weight)
93.         {
94.             int tmp;
95.             tmp = min1;
96.             min1 = min2;
97.             min2 = tmp;
98.         }
99.         for(i=2; i<LetterNum; i++)
100.         {
101.             if(Tree[i].weight<Tree[min1].weight)
102.             {
103.                 min2 = min1;
104.                 min1 = i;
105.             }
106.             else if(Tree[i].weight<Tree[min2].weight)
107.             {
108.                 min2 = i;
109.             }
110.         }
111.         Tree[i].weight = Tree[min1].weight + Tree[min2].weight;
112.         Tree[i].parent = -1;
113.         Tree[i].child0 = min1;
114.         Tree[i].child1 = min2;
115.         Tree[i].child2 = -1;
116.         Tree[min1].parent = i;
117.         Tree[min2].parent = i;
118.         i++;
119.     }
120.     //此处从最新生成的树开始搜索最小树根的树,树高比较大
121.     /*
122.     for(; i<NodeNum; i++)
123.     {
124.         j = i-1;
125.         while(Tree[j].parent != -1) j--;
126.         min1 = j--;
127.         while(Tree[j].parent != -1) j--;
128.         min2 = j--;
129.         while(Tree[j].parent != -1) j--;
130.         min3 = j--;
131.         if(Tree[min1].weight > Tree[min2].weight)
132.         {
133.             int tmp;
134.             tmp = min1;
135.             min1 = min2;
136.             min2 = tmp;
137.         }
138.         if(Tree[min1].weight > Tree[min3].weight)
139.         {
140.             int tmp;
141.             tmp = min1;
142.             min1 = min3;
143.             min3 = tmp;
144.         }
145.         if(Tree[min2].weight > Tree[min3].weight)
146.         {
147.             int tmp;
148.             tmp = min2;
149.             min2 = min3;
150.             min3 = tmp;
151.         }
152.         for(; j>=0; j--)
153.         {
154.             if(Tree[j].parent == -1)
155.             {
156.                 if(Tree[j].weight < Tree[min1].weight)
157.                 {
158.                     min3 = min2;
159.                     min2 = min1;
160.                     min1 = j;       
161.                 }
162.                 else if(Tree[j].weight < Tree[min2].weight)
163.                 {
164.                     min3 = min2;
165.                     min2 = j;
166.                 }
167.                 else if(Tree[j].weight < Tree[min3].weight)
168.                 {
169.                     min3 = j;
170.                 }
171.             }
172.         }*/
173.     for(; i<NodeNum; i++)
174.     {
175.         j = 0;
176.         while(Tree[j].parent != -1) j++;
177.         min1 = j++;
178.         while(Tree[j].parent != -1) j++;
179.         min2 = j++;
180.         while(Tree[j].parent != -1) j++;
181.         min3 = j++;
182.         if(Tree[min1].weight > Tree[min2].weight)
183.         {
184.             int tmp;
185.             tmp = min1;
186.             min1 = min2;
187.             min2 = tmp;
188.         }
189.         if(Tree[min1].weight > Tree[min3].weight)
190.         {
191.             int tmp;
192.             tmp = min1;
193.             min1 = min3;
194.             min3 = tmp;
195.         }
196.         if(Tree[min2].weight > Tree[min3].weight)
197.         {
198.             int tmp;
199.             tmp = min2;
200.             min2 = min3;
201.             min3 = tmp;
202.         }
203.         for(; j<=i-1; j++)
204.         {
205.             if(Tree[j].parent == -1)
206.             {
207.                 if(Tree[j].weight < Tree[min1].weight)
208.                 {
209.                     min3 = min2;
210.                     min2 = min1;
211.                     min1 = j;       
212.                 }
213.                 else if(Tree[j].weight < Tree[min2].weight)
214.                 {
215.                     min3 = min2;
216.                     min2 = j;
217.                 }
218.                 else if(Tree[j].weight < Tree[min3].weight)
219.                 {
220.                     min3 = j;
221.                 }
222.             }
223.         }
224.         Tree[i].weight = Tree[min1].weight + Tree[min2].weight + Tree[min3].weight;
225.         Tree[i].child0 = min1;
226.         Tree[i].child1 = min2;
227.         Tree[i].child2 = min3;
228.         Tree[i].parent = -1;
229.         Tree[min1].parent = i;
230.         Tree[min2].parent = i;
231.         Tree[min3].parent = i;
232.     }
233. }
235. //释放空间
236. void DestroyTree()
237. {
238.     if(Letters)
239.         free(Letters);
240.     if(Weights)
241.         free(Weights);
242.     if(Tree)
243.         free(Tree);
244. }
246. //打印生成树
247. void PrintTree()
248. {
249.     int i;
250.     printf("/n----CodeTree----/n");
251.     for(i=0; i<NodeNum; i++)
252.     {
253.         printf("%4d",Tree[i].weight);
254.         printf("%4d",Tree[i].parent);
255.         printf("%4d",Tree[i].child0);
256.         printf("%4d",Tree[i].child1);
257.         printf("%4d/n/n",Tree[i].child2);
258.     }
259. }
261. //显示字母编码表
262. void EncodeLetters()
263. {
264.     int i,j,k,t;
265.     char *code;
266.     char tmp;
268.     printf("/n其对应的编码表为:/n");
269.     code = (char*)malloc(LetterNum*sizeof(char));
270.     for(t=0; t<LetterNum; t++)
271.     {
272.         j = i = t; k = 0;
273.         while(Tree[j].parent != -1)
274.         {
275.             j = Tree[j].parent;
276.             if(Tree[j].child0 == i)
277.                 code[k++] = '0';
278.             else if(Tree[j].child1 == i)
279.                 code[k++] = '1';
280.             else code[k++] = '2';
281.             i = j;
282.         }
283.         code[k] = '/0';//结束符
284.         for(i=0; i<k/2; i++)//头尾置换
285.         {
286.             tmp = code[i];
287.             code[i] = code[k-i-1];
288.             code[k-i-1] = tmp;
289.         }
290.         printf("%c : %s/n",Letters[t],code);
291.     }
293.     free(code);
294. }
296. //编码
297. void Encode(char *lets)
298. {
299.     int i,j,k,t;
300.     char *code;
301.     char tmp;
303.     code = (char*)malloc(LetterNum*sizeof(char));
305.     CodeLen = 0;
306.     
307.     for(t = 0; lets[t] != '/0'; t++)
308.     {
309.         for(i=0; i<LetterNum; i++)
310.         {
311.             if(Letters[i] == lets[t])
312.                 break;
313.         }
314.         j = i; k = 0;
315.         while(Tree[j].parent != -1)
316.         {
317.             j = Tree[j].parent;
318.             if(Tree[j].child0 == i)
319.                 code[k++] = '0';
320.             else if(Tree[j].child1 == i)
321.                 code[k++] = '1';
322.             else code[k++] = '2';
323.             i = j;
325.             CodeLen++;
326.         }
327.         code[k] = '/0';//结束符
328.         for(i=0; i<k/2; i++)//头尾置换
329.         {
330.             tmp = code[i];
331.             code[i] = code[k-i-1];
332.             code[k-i-1] = tmp;
333.         }
334.         printf(code);
335.     }
336.     free(code);
337.     printf("/n");
338. }
340. //译码
341. void Decode(char *codes)
342. {
343.     int i,j,k=0;
344.     int ch;
345.     do
346.     {
347.         i = NodeNum-1;
348.         while(Tree[i].child0 != -1 && Tree[i].child1 != -1)
349.         {
350.             ch = codes[k++];
351.             if(ch == '/0')
352.                 break;
353.             if(ch == '0')
354.                 j = Tree[i].child0;
355.             else if(ch == '1')
356.                 j = Tree[i].child1;
357.             else j = Tree[i].child2;
358.             i = j;
359.         }
360.         //写入Decode
361.         printf("%c",Letters[i]);
362.     }while(ch != '/0');
363.     printf("/n");
364. }
366. //main
367. void main()
368. {
369.     char str[100];
370.     char code[100];
372.     printf("请输入要编码的字母串(长度小于100):/n");
373.     scanf("%s",str);
374.     if(!CountLetter(str))
375.     {
376.         printf("The string has error!/n");
377.         return ;
378.     }
379.     CreateTree();
380. //  PrintTree();
381.     EncodeLetters();
382.     printf("对应的编码为:");
383.     Encode(str);
384.     printf("总码长为: %d/n", CodeLen);
385.     printf("根据该编码，给出编码:");
386.     scanf("%s",code);
387.     printf("则输出字串:");
388.     Decode(code);
389. }