c++ 哈夫曼 数据结构-哈夫曼编译码,存储结构,编译码方法

问题描述

哈夫曼编译码,存储结构,编译码方法

求大神解答,编码跟译码应该怎样存储,编译码方法

#include
#include
using namespace std;
#define M 127
#define maxvalue 200000
struct CHARACTER//字母结构体
{char data;
int count;
}character1[M],character2[M],*character3;

typedef struct{
char c;
int weight;
int parent, lchild, rchild;
}HTNode, *HuffmanTree;

typedef struct CNode{
char co[20];
int start;
}codeNode;

typedef char **HuffmanCode;
HuffmanTree HT; //代表赫夫曼树
HuffmanCode HC; //代表赫夫曼编码

void savecharacter(CHARACTER character[])//保存字母信息
{
ofstream fout("txt1.txt",ios::out|ios::binary);
for(int i=0;i<M;i++)
fout.write((char*)&character[i], sizeof character[i]);
for(i=0;i<M;i++)
cout<<character[i].data<< " "<<character[i].count<<" ";
fout.close();
}

CHARACTER * readcharacter()//读取字母信息
{
ifstream fin("txt1.txt",ios::in|ios::binary);
for(int i=0;i<M;i++)
{fin.read((char*)&character2[i], sizeof character2[i]);
cout<<character2[i].data<<" "<<character2[i].count<<" "; }
return character2;
}

void initcharacter()
{ for(int i=0;i<M;i++)//初始化字母信息
{
character1[i].data=i;
character1[i].count=0;
}
}

CHARACTER * tongji(CHARACTER character[])//统计字符的个数及权值
{cout<<endl;
ifstream fin("txt.txt");
char ch;
int i=0;
while((ch=fin.get())!=EOF){//读到文件结尾为EOF标志
for(i=0;i<M;i++)
{
if(ch==character[i].data){character[i].count++;}
}
cout<<ch;
}
return character;
}

int countcharacter(CHARACTER character[])//统计文件中一共有多少个字符
{ int countchar=0;
int j=0;
int p1,p2;
p1=p2=0;

for(int i=0;i<M;i++)
{if(character[i].count!=0)
    countchar++;
}
    HTNode HH[2*M-1];//建立2*M-1大小的结构体数组
      cout<<endl;
  for( i=1;i<=M;i++)
  {
   if(character[i].count!=0)
   {
   HH[j].c=character[i].data;
   HH[j].weight=character[i].count;

   cout<<"字符"<<HH[j].c<<"权值  "<<HH[j].weight<<endl;
   j++;
   }
  }

return countchar;

}

void select_min(HuffmanTree ht,int k,int * x1,int * x2)
{
*x1=*x2=0;
int i,j=0;
int min=1000;
for(i=0;i<k;i++)//找最小权值

     {if(ht[i].weight<min&&ht[i].parent==0)
              {
                j=i;
                min=ht[i].weight;
              }
     }
      *x1=j;
      min=10000;
      for(i=0;i<k;i++)
      {if(ht[i].weight<min&&i!=*x1&&ht[i].parent==0)
      {j=i;min=ht[i].weight;}
      }
      *x2=j;

       cout<<*x1<<" "<<*x2<<endl;

}

HTNode* Buildtree(CHARACTER character[],int n)
{
    int j=0;
   int i;
   int x1,x2;
   int min1,min2;

  HTNode HH[2*M-1];//建立2*M-1大小的结构体数组
      cout<<endl;
  for( i=1;i<=M;i++)
  {
   if(character[i].count!=0)
   {
   HH[j].c=character[i].data;
   HH[j].weight=character[i].count;

   //cout<<"字符"<<HH[j].c<<"权值  "<<HH[j].weight<<endl;
   j++;
   }
  }
  for(i=0;i<n;i++)
{HH[i].parent=0;
HH[i].lchild=0;
HH[i].rchild=0;
}
for(i=n;i<2*n-1;i++)
{HH[i].parent=0;
HH[i].lchild=0;
HH[i].rchild=0;
HH[i].weight=0;
}

//建树
for(i=n;i<2*n-1;i++)
{
   select_min(HH,i,&x1,&x2);
   HH[x1].parent=i;
   HH[x2].parent=i;
   HH[i].lchild=x1;
   HH[i].rchild=x2;
    HH[i].weight=HH[x1].weight+HH[x2].weight;
 }//for
for(i=0;i<2*n-1;i++)
    cout<<HH[i].c<<" "<<HH[i].weight<<"  ";

return HH;
}

void Encode(HTNode HT[],int n)
{
int i,c,f;
char * cd;
int start;
 HC=(HuffmanCode)malloc((n+1)*sizeof(char *));
 cd=(char* )malloc(n*sizeof(char));
 cd[n-1]='';
 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[i].lchild==c)cd[--start]='0';
     else cd[--start]='1';
  HC[i]=(char*)malloc((n-start)*sizeof(char));
  strcpy(HC[i],&cd[start]);
  cout<<cd;
 }
 free(cd);
}

int main()
{
initcharacter();
character3= tongji(character1);
savecharacter(character3);
character3=readcharacter();
HuffmanTree Ht;
int n= countcharacter(character3);
Ht=Buildtree(character3,n);//将结构体数组地址返回到Ht
codeNode *t;
Encode(Ht,n);
return 0;
}

解决方案

http://www.cnblogs.com/hxf829/archive/2008/12/28/1659837.html

时间: 2024-08-17 18:26:04

c++ 哈夫曼 数据结构-哈夫曼编译码,存储结构,编译码方法的相关文章

大话数据结构二十一:图的存储结构之邻接多重表

1.引言: 若要删除左边的(V0,V2)这条边,需要对图下表的阴影两个结点进行删除操作. 更多精彩内容:http://www.bianceng.cnhttp://www.bianceng.cn/Programming/sjjg/ 2.邻接多重表的存储结构: iVex和jVex:是与某条边依附的两个顶点在顶点表中的下标. iLink:指向依附顶点iVex的下一条边. jLink:指向依附顶点jVex的下一条边. 3.邻接多重表示意图绘制: 作者:csdn博客 zdp072

大话数据结构二十:图的存储结构之十字链表

1. 引言: 对于有向图来说,邻接表是有缺陷的: 邻接表:关心了出度问题,想了解入度就必须要遍历整个图才知道. 逆邻接表:解决了入度,却不了解出度的情况. 能否把邻接表和逆邻接表结合起来呢?答案就是:使用十字链表. 2.十字链表存储结构: 顶点表结点结构: firstin:表示入边表头指针,指向该顶点的入边表中第一个结点. firstout:表示出边表头指针,指向该顶点的出边表中的第一个结点. 更多精彩内容:http://www.bianceng.cnhttp://www.bianceng.cn

大话数据结构十九:图的存储结构之邻接表

1. 邻接表(无向图)的特点: 有时候邻接矩阵并不是一个很好的选择: 如上图: 边数相对顶点较少,这种结构无疑是存在对存储空间的极大浪费. 邻接表: 数组和链表结合一起来存储. 1.)顶点用一个一位数组存储. 2.)每个顶点Vi的所有邻接点构成一个线性表,由于邻接点的个数不确定,所以我们选择单链表来存储. 更多精彩内容:http://www.bianceng.cnhttp://www.bianceng.cn/Programming/sjjg/ 2. 邻接表(有向图)的特点: 把顶点当弧尾建立的邻

大话数据结构十八:图的存储结构之邻接矩阵

1. 邻接矩阵(无向图)的特点: 图的邻接矩阵存储方式是用两个数组来表示图: 1.)一个一维数组存储存储图中顶点信息. 2.)一个二维数组(称为邻接矩阵)存储图中边或弧的信息. 上图中我们设置两个数组: 顶点数组:vertex[4] = {V0,V1,V2,V3} 边数组:arc[4][4] 为对称矩阵(0表示顶点间不存在边,1表示顶点间存在边) 2. 邻接矩阵(有向图)的特点: 无向图的边构成了一个对称矩阵,貌似浪费了一半的空间,那如果是有向图来存放,会不会把资源利用好呢? 更多精彩内容:ht

数据结构哈夫曼树代码怎么写

问题描述 数据结构哈夫曼树代码怎么写 哈夫曼树:输入一串只包含abcdefg8种字符的字符串,统计每种字符出现的次数,并据此创建相应的哈夫曼树. 这怎么写 解决方案 统计字符个数这个简单,你创建一个数组,将每个字符的ascii-'a',得到下标,对应下标+1http://blog.csdn.net/yaoowei2012/article/details/18180769 解决方案二: http://www.cnblogs.com/shiyangxt/archive/2008/12/05/1348

数据结构——赫夫曼树

1 基本概念 赫夫曼树(Huffman Tree)又称为最优树,是一类带权路径长度最短的树.本文仅讨论最优二叉树. 树的路径长度是指从树根到树中其余各个结点的路径长度之和.对具有n个结点的二叉树而言,完全二叉树具有最短的树的路径长度. 若在二叉树中,树叶结点带有权值,则有:结点的带权路径长度定义为从树根到该结点之间的路径长度与该结点上所带权值之积. 若树中有n个树叶结点,且每个树叶结点均带有权值,则有:树的带权路径长度定义为树中所有树叶结点的带权路径长度之和,可记为: 有时,也将树的路径长度称为

编码-哈夫曼树,请问大神们,下面的译码部分怎么没有输出?请大神们帮我修改下~~~(最好再加个能有个文件输出)

问题描述 哈夫曼树,请问大神们,下面的译码部分怎么没有输出?请大神们帮我修改下~~~(最好再加个能有个文件输出) #include #include #include #define maxsize 100 #define max 100 typedef struct { char data; int weight; int parent; int lchild; int rchild; }huffnode; typedef struct { char cd[max]; int start; }

大话数据结构二:线性表的链式存储结构(单链表)

1. 线性表的链式存储结构:指的是用一组任意的存储单元存储线性表的数据元素,这组存储单元可以是连续的,也可以是不连续的,这就意味着这些数据元素可以存在内存未被占用的任意位置. 2. 结点:结点由存放数据元素的数据域和存放后继结点地址的指针域组成. 1.)顺序存储结构中,每个数据元素只需要存数据元素的信息就可以了. 2.)链式存储结构中,除了要存储数据元素信息外,还要存储它的后继元素的存储地址. 3.)链表中第一个结点叫头结点,它的存储位置叫做头指针,它的数据域可以不存储任何信息,链表的最后一个结

数据结构的C++实现之栈的链式存储结构

当单链表限定只能在头部进行插入和删除操作的时候,即为链栈,一般我们会将单链表的头指针和栈的栈顶指针top合二 为一,通常对链栈来说,是不需要头节点的,因为我们维护了栈顶指针.对于链栈来说,基本不存在栈满的情况,除非内存 已经没有可以使用的空间,对于空栈来说,链表原定义是头指针指向空,那么链栈的空其实就是top = = NULL的时候.   示例代码:(改编自<大话数据结构>) #include <iostream> using namespace std; typedef int