Huffman编码(哈夫曼编码),

实现Huffman编码是用贪心算法来实现的,。实现Huffman最好的数据结构时优先级队列。整个算法的时间复杂度可以达到nlg(n),这里为了简单,没有实现最小堆,而使用的是STL中的set,通过实现正确的比较函数对象,每次可以取得优先级(字符出现频度最低)最大的值。但是这里的时间复杂度却提高了,因为操作set的选择时,时间复杂度时lgn,但是随着选择的,选择“未被访问的最高优先级的两个元素(flag=0)”的探测次数也为增大,平均探测次数是n/2,因此最后实现Huffman的时间复杂度将是n^2lg(n)。当然也可以通过记录每次选择元素时其在set中的位置(偏移量),下次选择时直接通过这个偏移量找到合适位置,探测的时间复杂度将会是1,最后实现Huffman的时间复杂度也可以达到nlog(n)。

具体代码如下:

  1. #include   
  2. #include   
  3. using namespace std;  
  4. struct Node  
  5. {  
  6.     int fu; 
  7.     int flag;  
  8.     struct Node *lc; 
  9.     struct Node *rc; 
  10. };  
  11. struct compare_node  
  12. {  
  13.     bool operator()(const Node* node1,const Node *node2)const  
  14.     {  
  15.         return node1->fu < node2->fu;  
  16.     }  
  17. };  
  18. set < Node *,compare_node> queue;   
  19. const int N = 6;  
  20. int s[N];  
  21. int f[N]; 
  22. struct Node *huffman()  
  23. {  
  24.     int i = 0;  
  25.     while(i
  26.     {  
  27.         Node  *child[2];  
  28.         set< Node *,compare_node>::iterator it = queue.begin();  
  29.         int lr = 0;  
  30.         while(it!=queue.end() && lr <2)  
  31.         {  
  32.             if((*it)->flag ==0) 
  33.             {  
  34.                 child[lr] =*it;  
  35.                 (*it)->flag = 1;  
  36.                 lr ++;  
  37.             }  
  38.             it++;  
  39.         }  
  40.         Node *parent = new Node;  
  41.           
  42.         parent->flag = 0;  
  43.         parent->lc = child[0];  
  44.         parent->rc = child[1];  
  45.         parent->fu = child[0]->fu + child[1]->fu;  
  46.         queue.insert(parent);  
  47.         i++;  
  48.           
  49.     }  
  50.     int count = queue.size();  
  51.     set ::reverse_iterator rit = queue.rbegin();  
  52.     if(rit!=queue.rend())  
  53.         return *rit;  
  54.     else  
  55.         return NULL;  
  56. }  
  57.  
  58. void print(Node * root,int c)  
  59. {  
  60.     if(root == NULL)  
  61.         return;  
  62.     else  
  63.     {  
  64.         if( root->lc != NULL)  
  65.         {  
  66.             s[c++] = 0;  
  67.             print(root->lc,c);  
  68.         }  
  69.         if(root->rc!=NULL)  
  70.         {  
  71.             c--;  
  72.             s[c++]=1;  
  73.             print(root->rc,c);  
  74.         }   
  75.         if(root->lc == NULL && root->rc == NULL)  
  76.         {  
  77.             cout << root->fu <<"  ";  
  78.             int i =0;  
  79.             for(i=0;i
  80.                 cout << s[i];  
  81.             cout << endl;  
  82.         }  
  83.     }  
  84. }  
  85. int main()  
  86. {  
  87.     int i =0;  
  88.     Node *p = NULL;  
  89.     for(i=0;i
  90.     {  
  91.         cin>>f[i];  
  92.         p = new Node;  
  93.         p->flag = 0;  
  94.         p->fu = f[i];  
  95.         p->lc = NULL;  
  96.         p->rc = NULL;  
  97.         queue.insert(p);  
  98.     }  
  99.     Node *node = huffman();  
  100.     print(node,0);  
  101. }  

你可能感兴趣的:(C,数据结构)