求助

1808035990

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #define MAXNUM 50
   
4. 
   
5. typedef struct
   
6. {
   
7.         char data;
   
8.         int weight;
   
9.         int parent;
   
10.         int leftchild;
    
11.         int rightchild;
    
12. }HuffNode;
    
13. 
    
14. typedef struct
    
15. {
    
16.         char cd[MAXNUM];
    
17.         int start;
    
18. }HuffCode;
    
19. 
    
20. int HaffmanCreat(HuffNode *ht)
    
21. {
    
22.         int i,k,n,min1,min2,lnode,rnode;
    
23.         printf("请输入元素个数：");
    
24.         scanf("%d",&n);
    
25.         for(i=1;i<=n;i++)            //输入结点值和信息
    
26.         {
    
27.                 getchar();
    
28.                 printf("第%d个元素的=>\n\t结点值：",i);
    
29.                 scanf("%c",&ht[i].data);
    
30.                 printf("\t权重：");
    
31.                 scanf("%d",&ht[i].weight);
    
32.         }
    
33.         for(i=1;i<=2*n-1;i++)       //对数组初始化
    
34.         {
    
35.                 ht[i].parent=0;
    
36.                 ht[i].leftchild=0;
    
37.                 ht[i].rightchild=0;
    
38.         }
    
39.         for(i=n+1;i<=2*n-1;i++)
    
40.         {
    
41.                 min1=min2=32767;
    
42.                 lnode=1;
    
43.                 rnode=1;
    
44.                 for(k=1;k<=i-1;k++)  //从数组中找权值最小的两个结点
    
45.                         if(ht[k].parent==0)        //在尚未参与构造的结点中找
    
46.                                 if(ht[k].weight<min1)
    
47.                                 {
    
48.                                         min2=min1;
    
49.                                         rnode=lnode;
    
50.                                         min1=ht[k].weight;
    
51.                                         lnode=k;
    
52.                                 }
    
53.                                 else if(ht[k].weight<min2)
    
54.                                 {
    
55.                                         min2=ht[k].weight;
    
56.                                         rnode=k;
    
57.                                 }
    
58.                         ht[i].weight=min1+min2;
    
59.                         ht[i].leftchild=lnode;
    
60.                         ht[i].rightchild=rnode;
    
61.                         ht[lnode].parent=i;
    
62.                         ht[rnode].parent=i;
    
63.         }
    
64.         printf("哈夫曼树已成功建立！\n");
    
65.         return n;
    
66. }
    
67. 
    
68. void PrintBTNode(HuffNode *hf, int index,int n)    //横向输出
    
69. {
    
70.         if(hf[index].leftchild!=0||hf[index].rightchild!=0)
    
71.         {
    
72.                 PrintBTNode(hf,hf[index].rightchild,n+1);
    
73.                 if(n!=0)
    
74.                 {
    
75.                         for(int i=0;i<4*(n-1);i++)
    
76.                         {
    
77.                                 printf("%s"," ");
    
78.                         }
    
79.                         printf("%s","---");
    
80.                 }
    
81.                 printf("o\n");
    
82.                 PrintBTNode(hf,hf[index].leftchild,n+1);
    
83.         }
    
84.         else
    
85.         {
    
86.                 if(n!=0)
    
87.                 {
    
88.                         for(int i=0;i<4*(n-1);i++)
    
89.                         {
    
90.                                 printf("%s"," ");
    
91.                         }
    
92.                         printf("%s","---");
    
93.                 }
    
94.                 printf("%c \n",hf[index].data);
    
95.         }
    
96. }
    
97. 
    
98. void Encoding(HuffNode ht[],HuffCode hcd[],int n)  //哈夫曼编码
    
99. {
    
100.         HuffCode d;
     
101.         int i,k,f,c;
     
102.         for(i=1;i<=n;i++)
     
103.         {
     
104.                 d.start=n+1;
     
105.                 c=i;
     
106.                 f=ht[i].parent;
     
107.                 while(f!=0)
     
108.                 {
     
109.                         if(ht[f].leftchild==c)
     
110.                                 d.cd[--d.start]='0';
     
111.                         else
     
112.                                 d.cd[--d.start]='1';
     
113.                         c=f;
     
114.                         f=ht[f].parent;
     
115.                 }
     
116.                 hcd[i]=d;
     
117.         }
     
118.         printf("输出哈夫曼编码：\n");
     
119.         for(i=1;i<=n;i++)
     
120.         {
     
121.                 printf("%c:",ht[i].data);
     
122.                 for(k=hcd[i].start;k<=n;k++)
     
123.                         printf("%c",hcd[i].cd[k]);
     
124.                 printf("\n");
     
125.         }
     
126. }
     
127. 
     
128. int main()
     
129. {
     
130.         HuffNode *ht;
     
131.         HuffCode *hcd;
     
132.         int n;
     
133.         ht=(HuffNode *)malloc(sizeof(HuffNode));
     
134.         hcd=(HuffCode *)malloc(sizeof(HuffCode));
     
135.         n=HaffmanCreat(ht);
     
136.         PrintBTNode(ht,2*n-1,0);
     
137.         Encoding(ht,hcd,n);
     
138. }

复制代码

FishC

您好！看到你的代码，我发现你的问题可能出在scanf函数上。你的代码缺少了头文件，可以在开头添加<cstdio>来包含该函数所在的头文件。

另外，你声明了一个HuffNode类型的数组ht，但是没有给其分配内存空间。你可以使用动态内存分配函数malloc来分配内存。修改代码如下：

1. #include <cstdio>
   
2. #include <cstdlib>
   
3. #define MAXNUM 50
   
4. 
   
5. typedef struct
   
6. {
   
7.     char data;
   
8.     int weight;
   
9.     int parent;
   
10.     int leftchild;
    
11.     int rightchild;
    
12. } HuffNode;
    
13. 
    
14. typedef struct
    
15. {
    
16.     char cd;
    
17.     int start;
    
18. } HuffCode;
    
19. 
    
20. int HaffmanCreat(HuffNode *ht)
    
21. {
    
22.     int i, k, n, min1, min2, lnode, rnode;
    
23.     printf("请输入元素个数：");
    
24.     scanf("%d", &n);
    
25.     ht = (HuffNode *)malloc(sizeof(HuffNode) * (2 * n - 1));
    
26.     for (i = 1; i <= n; i++) {
    
27.         printf("请输入第%d个字符和权重：", i);
    
28.         scanf(" %c%d", &(ht[i].data), &(ht[i].weight));
    
29.         ht[i].parent = 0;
    
30.         ht[i].leftchild = 0;
    
31.         ht[i].rightchild = 0;
    
32.     }
    
33.     for (i = n + 1; i < 2 * n - 1; i++) {
    
34.         min1 = min2 = MAXNUM;
    
35.         lnode = rnode = 0;
    
36.         for (k = 1; k <= i - 1; k++) {
    
37.             if (ht[k].parent == 0) {
    
38.                 if (ht[k].weight < min1) {
    
39.                     min2 = min1;
    
40.                     rnode = lnode;
    
41.                     min1 = ht[k].weight;
    
42.                     lnode = k;
    
43.                 } else if (ht[k].weight < min2) {
    
44.                     min2 = ht[k].weight;
    
45.                     rnode = k;
    
46.                 }
    
47.             }
    
48.         }
    
49.         ht[lnode].parent = i;
    
50.         ht[rnode].parent = i;
    
51.         ht[i].weight = ht[lnode].weight + ht[rnode].weight;
    
52.         ht[i].leftchild = lnode;
    
53.         ht[i].rightchild = rnode;
    
54.     }
    
55.     return 0;
    
56. }
    
57. 
    
58. int main()
    
59. {
    
60.     HuffNode *ht;
    
61.     HaffmanCreat(ht);
    
62.     return 0;
    
63. }

复制代码

这样就修复了你的代码中的错误，并且为ht数组分配了内存空间。希望对你有帮助！如果还有其他问题，请随时提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。