软件实现信源压缩中的香农编码和哈夫曼编码

[wohuaihao]

软件实现信源压缩中的香农编码和哈夫曼编码。要求给定一个离散的无记忆信源的符号个数和发生的概率，能计算和输出显示该信源的信息熵，香农编码和哈夫曼编码的码字，码长，平均码长和编码效率，并对两种编码的性能进行比较




恳求各位老大速速救济啊！！！！！！！！！！！！！！！！！！！！！

[ltc_mouse]

google
baidu

[猫已经找不回了]

勾起了信息论考试的回忆。。
楼主，不要急，先分别搜索下2种编码的代码，然后再针对功能改改。
帮你找了个哈夫曼编码

哈夫曼编码的源代码 
                                    
#include"stdio.h" 
#include"stdlib.h"
#include"string.h"

typedef char ElemType; 
typedef struct
{ 
   ElemType elem;
   unsigned int m_weight; 
   unsigned int parent,lchild,rchild; 
}HTNode,*HuffmanTree; 

typedef char** HuffmanCode; 
typedef int Status; 
typedef struct weight
{
  char elem; 
  unsigned int m_weight; 
}Weight; // save the information of the symbolizes; 

void HuffmanCoding(HuffmanTree *,HuffmanCode *,Weight *,int); 
void Select(HuffmanTree,int,int *,int *); 
void OutputHuffmanCode(HuffmanTree,HuffmanCode,int); 

Status main(void) 
{ 
  HuffmanTree HT; 
  HuffmanCode HC; 
  Weight *w; 
  char c;     // the symbolizes;
  int i,n;      // the number of elements; 
  int wei;    // the weight of a element; 

  printf("input the tatol number of the Huffman Tree:" ); 
  scanf("%d",&n); 
  w=(Weight *)malloc(n*sizeof(Weight)); 
  for(i=0;i<n;i++)
  { 
    printf("input the element & its weight:"); 
    scanf("%1s%d",&c,&wei); 
    w[i].elem=c; 
    w[i].m_weight=wei; 
  } 

  HuffmanCoding(&HT,&HC,w,n); 
  OutputHuffmanCode(HT,HC,n); 
  return 1; 

} 

void HuffmanCoding(HuffmanTree *HT,HuffmanCode *HC,Weight *w,int n)
{ 
  int i,m,s1,s2,start,c,f; 
  char *cd; 
  HuffmanTree p; 
  if(n<=1)
  return; 

  m=2*n-1; 
  (*HT)=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
  for(i=1;i<=n;++i)
  { 
     (*HT)[i].elem=w[i-1].elem; 
     (*HT)[i].m_weight=w[i-1].m_weight; 
     (*HT)[i].parent=(*HT)[i].lchild=(*HT)[i].rchild=0; 
  } 

  for(;i<=m;++i)
  { 
    (*HT)[i].elem='0'; 
    (*HT)[i].m_weight=(*HT)[i].parent=(*HT)[i].lchild=(*HT)[i].rchild=0; 
  } 

  for(i=n+1;i<=m;++i)
  { 
    Select(*HT,i-1,&s1,&s2); 
    (*HT)[s1].parent=i;(*HT)[s2].parent=i; 
    (*HT)[i].lchild=s1;(*HT)[i].rchild=s2; 
    (*HT)[i].m_weight=(*HT)[s1].m_weight+(*HT)[s2].m_weight; 
  } 

  (*HC)=(HuffmanCode)malloc(n*sizeof(char*)); 
  cd=(char *)malloc(n*sizeof(char)); 
  cd[n-1]='\0'; 
  for(i=1;i<=n;++i)
  { 
     start=n-1; 
     for(c=i,f=(*HT)[i].parent;f!=0;c=f,f=(*HT)[f].parent)
 { 
       if((*HT)[f].lchild==c) cd[--start]='0'; 
       else cd[--start]='1'; 
     } 

     (*HC)[i]=(char *)malloc((n-start)*sizeof(char));
     strcpy((*HC)[i],&cd[start]); 
  } 
} 

void Select(HuffmanTree HT,int n,int *s1,int *s2) 
{ 
  int i; 
  (*s1)=(*s2)=0; 
  for(i=1;i<=n;i++)
  { 
    if(HT[i].m_weight<HT[(*s2)].m_weight&&HT[i].parent==0&&(*s2)!=0)
{ 
      if(HT[i].m_weight<HT[(*s1)].m_weight)
  { 
  (*s2)=(*s1); 
  (*s1)=i; 
      } 
      else (*s2)=i; 

    } 

    if(((*s1)==0||(*s2)==0)&&HT[i].parent==0)
{ 
      if((*s1)==0) (*s1)=i; 
      else if((*s2)==0)
  { 
  if(HT[i].m_weight<HT[(*s1)].m_weight)
  { 
  (*s2)=(*s1); 
  (*s1)=i; 
  } 
  else (*s2)=i; 
      } // end of else if 
    } // end of if 
  } // end of for 

  if((*s1)>(*s2))
  { 
    i=(*s1); 
(*s1)=(*s2); 
(*s2)=i; 
  } 
  return; 
} 

void OutputHuffmanCode(HuffmanTree HT,HuffmanCode HC,int n) 
{ 
  int i; 
  printf("\nnumber---element---weight---huffman code\n"); 
  for(i=1;i<=n;i++) 
    printf("  %d        %c         %d        %s\n",i,HT[i].elem,HT[i].m_weight,HC[i]); 
}  

[wohuaihao]

感谢大虾，形势所逼，改改是可以的，但思想能否再详细下！

[chin_chen]

第一个参考
url=http://kepu.ccut.edu.cn/100k/read-htm-tid-9230.html][/url]

[ForestDB]

这有什么思路，理解编码算法，实现之。
--!!

[chin_chen]

]1．建树函数[code=C/C++
构建哈夫曼树的目的一是为了得到哈夫曼编码表，二是为了压缩文件解压缩时使用，所以哈夫曼树要存入压缩文件。构造的方法是：所有节点组成森林，合并权值（这里为字符的频次）最小的两棵树，用一个新节点作为它们的父节点，它的权值为孩子节点权值之和。将组成的新树放入森林中，重新排序，重复以上步骤，直到整个森林合并成一棵树。程序编写如下：
void BuildHuffmanTree(PSYMBOL_DEF psyms, PDWORD pdwc)
{
UINT i;
PSYMBOL_DEF psdLast, psd1BeforeLast;
DWORD dwcSymDefs = *pdwc;
if ( dwcSymDefs == 1 )
{
psyms[1] = psyms[0]; table
memset( &psyms[0], 0, sizeof( psyms[0] ));
psyms[0].probability = 1.0;
psyms[0].wID = 1;
psyms[0].wIDLeft = (WORD)-1;
psyms[0].wIDRight = 0;
non-branch sym def
psyms[0].wIDUp = (WORD)-1;
psyms[1].wIDUp= 1;
non-branch sym def
*pdwc += 1;
return;
}[/code]

[chin_chen]

1．建树函数
构建哈夫曼树的目的一是为了得到哈夫曼编码表，二是为了压缩文件解压缩时使用，所以哈夫曼树要存入压缩文件。构造的方法是：所有节点组成森林，合并权值（这里为字符的频次）最小的两棵树，用一个新节点作为它们的父节点，它的权值为孩子节点权值之和。将组成的新树放入森林中，重新排序，重复以上步骤，直到整个森林合并成一棵树。程序编写如下：

void BuildHuffmanTree(PSYMBOL_DEF psyms, PDWORD pdwc)
{
UINT i;
PSYMBOL_DEF psdLast, psd1BeforeLast;
DWORD dwcSymDefs = *pdwc;
if ( dwcSymDefs == 1 )
{
psyms[1] = psyms[0]; table
memset( &psyms[0], 0, sizeof( psyms[0] ));
psyms[0].probability = 1.0;
psyms[0].wID = 1;
psyms[0].wIDLeft = (WORD)-1;
psyms[0].wIDRight = 0;
non-branch sym def
psyms[0].wIDUp = (WORD)-1;
psyms[1].wIDUp= 1;
non-branch sym def
*pdwc += 1;
return;
}

[chin_chen]

2．编码表函数
由于哈夫曼编码是变长编码，因此必须在编码表中记录编码的位数。建立编码表的方法是：从叶节点出发开始回朔，如果叶节点是它的父节点的左孩子，编码为0，反之，编码为1。由于这种编码是倒序的，在程序中，用从右边加入编码的方法使其变为正序。当回朔到根节点时，编码结束。程序编写如下：

void BuildSymbolSequences(PSYMBOL_DEF psyms, DWORD dwc)
{
DWORD sequ, len;
for (UINT i = 0; i < dwc; i++)
{
if (psyms[i].wIDLeft == (WORD)-1 &&
psyms[i].wIDRight == (WORD)-1)
{
PSYMBOL_DEF psd, psd2;
psd = &psyms[i];
len = sequ = 0;
while (psd->wIDUp != (WORD)-1)
{
psd2 = SymDefId2Node(psyms, dwc, psd->wIDUp);
if (psd->wID == psd2->wIDRight)
sequ |= 0×1;
psd = psd2;
++len;
sequ <<= 1;
}
sequ >>= 1;
psyms[i].dwSequence = sequ;
psyms[i].bySequLen = (BYTE)len;
}
}
return;
}

[chin_chen]

3．压缩函数
压缩编码写入的关键是如何将变长的编码组织到写入变量中，本程序采用无符号的长整型为编码写入的缓冲变量。函数编写如下：

void CompressData(PSYMBOL_DEF psyms, DWORD dwc,
void* pIn, DWORD dwcInBytes,
void* pOut, OUT PDWORD pdwcOutBytes)
{
PSYMBOL_DEF psdSym;
DWORD dwcOutBytes = 0;
DWORD dw, filled, sequ;
dw = filled = 0;
for (UINT i = 0; i < dwcInBytes; i++)
{
psdSym = Sym2Node(psyms, dwc, ((BYTE*)pIn)[i]);
sequ = psdSym->dwSequence;
for (UINT i2 = 0; i2 < psdSym->bySequLen; i2++)
{
dw |= (sequ & 1);
dw = ror32(dw, 1);
sequ >>= 1;
++filled;
if (filled == 32)
{
((DWORD*)pOut)[dwcOutBytes++] = dw;
dw = filled = 0;
}
}
}
if (filled != 0)
{
dw >>= 32 - filled;
((DWORD*)pOut)[dwcOutBytes++] = dw;
}
*pdwcOutBytes = dwcOutBytes * 4;
return;
}

[chin_chen]

4．解压函数
有了原文件字符集的哈夫曼树，在读取编码时，从树的根节点出发，如果编码为0，走向左孩子，编码为1，走向右孩子；如果当前节点为叶子节点，将该节点的字符写入解压缩文件，重新从根节点出发。函数编写如下：

void DecompressData(PSYMBOL_DEF_SHORT psdsTbl, DWORD dwcTblItems,
void* pInput, DWORD dwcSymsComp,void* pOut)
{
DWORD dw= ((DWORD*)pInput)[0];
PSYMBOL_DEF_SHORT psds;
DWORD done = 0, InDwsDone = 0;
for (UINT i = 0; i < dwcSymsComp; i++)
{
psds = psdsTbl;
while (TRUE)
{
if ( (dw & 1) == 0)
{
psds = SymShortDefId2Node(psds, dwcTblItems, psds->wIDLeft);
}
else
{
psds = SymShortDefId2Node(psds, dwcTblItems, psds->wIDRight);
}
if (++done == 32)
{
dw = ((DWORD*)pInput)[++InDwsDone];
done = 0;
}
else
dw >>= 1;
if (psds->wIDLeft == (WORD)-1 && psds->wIDRight == (WORD)-1)
{
break;
}
}
((BYTE*)pOut)[i] = psds->sym;
}
Return;
}

[pengzhixi]

mark

[chin_chen]

第二篇参考文献。祝楼主好运！
http://www.noreal.com.cn/2008/07/dynamic-huffman-coding.html

[chin_chen]

最后一个篇了。累死我了。
www.jdl.ac.cn/user/lyqing/SourceCoding/02_25_Huffanman.ppt