关于赫夫曼编码中的代码有点不理解，请高手多指点！

隨鈊乄鎍慾

先上代码：（问题在红色字体部分）：原码在53课时赫夫曼编码C语言实现  由于代码太多我从上面选了一部分复制下来：

1. htTree * buildTree(char *inputString)
   
2. {
   
3.         
   
4.         int * probability = (int *)malloc(sizeof(int)*256);
   
5.         
   
6. 
   
7.         for(int i=0; i<256; i++)
   
8.                 probability[i]=0;
   
9. 
   
10. 
    
11.         for(i=0; inputString[i]!='\0'; i++)
    
12.                 probability[(unsigned char) inputString[i]]++;
    
13. 
    
14. 
    
15.         pQueue * huffmanQueue;
    
16.         initPQueue(&huffmanQueue);
    
17. 
    
18. 
    
19.         for(i=0; i<256; i++)
    
20.                 if(probability[i]!=0)
    
21.                 {
    
22.                         htNode *aux = (htNode *)malloc(sizeof(htNode));
    
23.                         aux->left = NULL;
    
24.                         aux->right = NULL;
    
25.                         aux->symbol = (char) i;
    
26.                         
    
27.                         addPQueue(&huffmanQueue,aux,probability[i]);
    
28.                 }
    
29. 
    
30. 
    
31. [color=#ff0000]        [/color][color=#000000]free(probability) [/color][color=#ff0000]; //我调试了程序之后发现这里为什么是每次循环都要释放一次，而不是一次就释放完成！为什么！[/color]
    
32. 
    
33. 
    
34.         while(huffmanQueue->size!=1)
    
35.         {
    
36.                 int priority = huffmanQueue->first->priority;
    
37.                 priority+=huffmanQueue->first->next->priority;
    
38. 
    
39.                 htNode *left = getPQueue(&huffmanQueue);
    
40.                 htNode *right = getPQueue(&huffmanQueue);
    
41. 
    
42.                 htNode *newNode = (htNode *)malloc(sizeof(htNode));
    
43.                 newNode->left = left;
    
44.                 newNode->right = right;
    
45. 
    
46.                 addPQueue(&huffmanQueue,newNode,priority);
    
47.         }
    
48. 
    
49. 
    
50.         htTree *tree = (htTree *) malloc(sizeof(htTree));
    
51. 
    
52.         tree->root = getPQueue(&huffmanQueue);
    
53.         
    
54.         return tree;
    
55. }
    
56. 
    
57. void encode(hlTable *table, char *stringToEncode)
    
58. {
    
59.         hlNode *traversal;
    
60.         
    
61.         printf("\nEncoding\nInput string : %s\nEncoded string : \n",stringToEncode);
    
62. 
    
63. 
    
64. 
    
65.         for(int i=0; stringToEncode[i]!='\0'; i++)
    
66.         {
    
67.                 traversal = table->first;
    
68.                 while(traversal->symbol != stringToEncode[i])
    
69.                         traversal = traversal->next;
    
70.                 printf("%s",traversal->code);
    
71.         }
    
72. 
    
73.         printf("\n");
    
74. }

复制代码

小甲鱼

1. htTree * buildTree(char *inputString)
   
2. {
   
3.         //The array in which we calculate the frequency of the symbols
   
4.         //Knowing that there are only 256 posibilities of combining 8 bits
   
5.         //(256 ASCII characters)
   
6.         int * probability = (int *)malloc(sizeof(int)*256);
   
7.         
   
8.         //We initialize the array
   
9.         for(int i=0; i<256; i++)
   
10.                 probability[i]=0;
    
11. 
    
12.         //We consider the symbol as an array index and we calculate how many times each symbol appears
    
13.         for(int i=0; inputString[i]!='\0'; i++)
    
14.                 probability[(unsigned char) inputString[i]]++;
    
15. 
    
16.         //The queue which will hold the tree nodes
    
17.         pQueue * huffmanQueue;
    
18.         initPQueue(&huffmanQueue);
    
19. 
    
20.         //We create nodes for each symbol in the string
    
21.         for(int i=0; i<256; i++)
    
22.                 if(probability[i]!=0)
    
23.                 {
    
24.                         htNode *aux = (htNode *)malloc(sizeof(htNode));
    
25.                         aux->left = NULL;
    
26.                         aux->right = NULL;
    
27.                         aux->symbol = (char) i;
    
28.                         
    
29.                         addPQueue(&huffmanQueue,aux,probability[i]);
    
30.                 }
    
31. 
    
32.         //We free the array because we don't need it anymore
    
33.         free(probability);
    
34. 
    
35.         //We apply the steps described in the article to build the tree
    
36.         while(huffmanQueue->size!=1)
    
37.         {
    
38.                 int priority = huffmanQueue->first->priority;
    
39.                 priority+=huffmanQueue->first->next->priority;
    
40. 
    
41.                 htNode *left = getPQueue(&huffmanQueue);
    
42.                 htNode *right = getPQueue(&huffmanQueue);
    
43. 
    
44.                 htNode *newNode = (htNode *)malloc(sizeof(htNode));
    
45.                 newNode->left = left;
    
46.                 newNode->right = right;
    
47. 
    
48.                 addPQueue(&huffmanQueue,newNode,priority);
    
49.         }
    
50. 
    
51.         //We create the tree
    
52.         htTree *tree = (htTree *) malloc(sizeof(htTree));
    
53. 
    
54.         tree->root = getPQueue(&huffmanQueue);
    
55.         
    
56.         return tree;
    
57. }

复制代码

调用一次 buildTree() 函数只调用一次 free(probability); 噢，写在中间是因为后边已经不需要它了，所以赶紧释放，免得后边忘记释放导致内存泄漏。

不知道有木有充分理解哥们的问题，如有不对请继续回复。

隨鈊乄鎍慾

小甲鱼 发表于 2015-3-15 20:42
调用一次 buildTree() 函数只调用一次 free(probability); 噢，写在中间是因为后边已经不需要它了，所 ...

哦，我又调试了一下。for 偱环里256次每次都要跑到free(probability)代码上去跑一趟，我以为每跑去一次它都释放了一次

隨鈊乄鎍慾

小甲鱼 发表于 2015-3-15 20:42
调用一次 buildTree() 函数只调用一次 free(probability); 噢，写在中间是因为后边已经不需要它了，所 ...

补充一点：
for(i=0; i<256; i++)
                if(probability!=0)
                {
                        htNode *aux = (htNode *)malloc(sizeof(htNode));
                        aux->left = NULL;
                        aux->right = NULL;
                        aux->symbol = (char) i;
                       
                        addPQueue(&huffmanQueue,aux,probability);
                }//如果这里加一个分号的话，就好理解了它就不会每次都跑下边去free()一次了。我试过了加一个分号的话，这个偱环就不会每次跑下去了。而是等for 偱环执行完了才去执行一次free()

        //We free the array because we don't need it anymore
        free(probability);