哈夫曼文件压缩源文件+头文件

#ifndef  _YASUO_

#define   _YASUO_

int count; //临时变量

/结构体1：字符的出现次数

struct  _symbol{

     char character;

     unsigned  int number;

};

//struct _symbol symbol_list[128];

/结构体2：文件的状态记录

struct  _filestate{

     char symbol_count;

     struct  _symbol symbol_list[ 128];

};

/结构体3：哈夫曼树的结点

struct  _node{

     unsigned  int temp;

     struct  _symbol* symbol;

     struct  _node* left;

     struct  _node* right;

};

typedef  struct  _node _node;

/结构体4：字符的编码字典项

struct  _dictionary_itme{

     struct  _symbol* symbol;

     char coding[ 20];

};

/结构体5：字符的编码字典

struct  _dictionary{

     int count;

     struct  _dictionary_itme itme[ 128];

};

void  init(); //初始化   

void  compressing( char*); //压缩

void  uncompressing(); //解压

void  read_file( char*); //读取文件

_node*  creat_haffman(); //创建哈夫曼树

_node*  creat_node( struct  _symbol*); //创建节点

void  creat_dictionary(_node*); //创建压缩字典

void  coding_file( char*); //编码

void  creat_haffman_coding( char*,_node*); //创建哈夫曼编码

#endif

//==============================================

#include   <stdio.h>

#include   <stdlib.h>

#include   <fcntl.h>

#include   <sys/stat.h>

#include   <string.h>

#include   "yasuo.h"

//变量区

int i =  0;

char* head =  NULL;

struct _filestate filestate;   //结构体2：文件的状态记录

_node** node_list;

_node* root;

struct _dictionary dictionary; //结构体5：字符的编码字典

void  init()

{

     int i;

    count= 0;

     bzero(&filestate,sizeof(filestate));

     bzero(&dictionary,sizeof(dictionary));

}

void  creat_haffman_coding( char* coding,_node* _root)

{

     if(_root-> left== NULL&&_root-> right== NULL)

    {

         strcpy(dictionary. itme[i]. coding,head);

        dictionary. itme[i]. symbol = _root-> symbol;

         //printf("%d.%s %c %d\n",i,dictionary.itme[i].coding,dictionary.itme[i].symbol->character,dictionary.itme[i].symbol->number);

        i++;        

         return;

    }   

     if(_root-> left!= NULL)

    {

        *coding= '0';

         creat_haffman_coding(coding+ 1,_root-> left);

        *coding =  0;

    }

     if(_root-> left!= NULL)

    {

        *coding= '1';

         creat_haffman_coding(coding+ 1,_root-> right);

        *coding =  0;

         return;

    }

}

int g= 0;

void  bianli(_node* node)

{

     if(node ==  NULL) return;

     bianli(node-> left);

     printf( "%d.%d\n",g++,node-> temp);

     bianli(node-> right);

}

void  creat_dictionary(_node* _root)

{

     int i;

    dictionary. count = filestate. symbol_count;

     char coding[ 20] = { 0};

    head = coding;

     //printf("%d \n",dictionary.count);

     creat_haffman_coding(coding,_root);

     return;

}

char*  find( char ch)

{

     int i =  0;

     while(i<dictionary. count)

         if(ch==dictionary. itme[i]. symbol-> character)

             return dictionary. itme[i]. coding;

         else i++;

     return  NULL;

}

void  coding_file( char* filename) //将源文件转化为哈弗曼编码

{

     int fd =  open(filename,O_RDONLY);

     if(fd< 0)  perror( " open error!");

     char filename2[ 20] = { 0};

     sprintf(filename2, "%s.vvei",filename);

     //printf("%s\n",filename2);

     int fd2 =  open(filename2,O_CREAT|O_RDWR);

     if(fd2< 0)  perror( " open2 error!");

     unsigned  char temp =  0;

     printf( "1.%d\n",sizeof(filestate));

     int r;

    r =  write(fd2,&filestate,sizeof(filestate));

     if(r< 0) perror( " write error!");

     printf( "3.%d\n",r);

     // struct _filestate f;

     // r = read(fd2,&f,sizeof(f));

     // if(r<0)perror("read error!");

     // printf("4.%d\n",r);

     // printf("%d %d\n",f.symbol_count,filestate.symbol_count);

     unsigned  char ch =  0;

     unsigned  char ch1 =  0;

     char* code =  "\0";

     int flag =  0;

     printf( "%d\n",*code);

     int gg= 55;

     while( 1) //将读到的字符转成哈夫曼编码再写到压缩文件中去

    {

         if(flag> 7)

        {   

             if( write(fd2,&ch1, 1)< 0)  perror( "writecode error!");

             //printf("%d\n%s\n",ch1,code);

            flag =  0;

            ch1 =  0;

             //break;

        }

         if(*code== '0')

        {

            ch1*= 2;

            code+= 1;

            flag++;

        }

         else  if(*code== '1')

        {

            ch1*= 2;

            ch1++;

            code+= 1;

            flag++;

        }

         else  if(*code== 0) 

        {

             if( read(fd,&ch, 1))

            {

                code =  find(ch);

                 //printf("%c %s\n",ch,code);

            }

             else 

            {

                 char t = flag% 8;

                ch1*=t;

                 if( write(fd2,&ch1, 1)< 0)  perror( "writecode error!");

                 if( write(fd2,&t, 1)< 0)  perror( "writecode error!");

                 break;

            }

        }

         else  perror( "code error!");

    }

}

void  read_file( char* filename)

{

     int i =  0;

     int result =  0;

     unsigned  char ch= 0;

     // FILE *f = fopen(filename,"r");

     // if(f==NULL){perror("fopen error!");}

     int fd =  open(filename,O_RDONLY);

     if(fd< 0) { perror( " open error"); return;}

     unsigned  char symbol[ 128] = { 0};

     while(result =  read(fd,&ch, 1))

    {

         if(result< 0)

            { perror( "readfile error!"); return;}

        symbol[ch]++;

    }

     for(i= 0;i< 128;i++)

    {

         if(!symbol[i])

             continue;

        filestate. symbol_list[filestate. symbol_count]. character = i;

        filestate. symbol_list[filestate. symbol_count++]. number = symbol[i];

         //printf("%d. %d %d\n",filestate.symbol_count,filestate.symbol_list[filestate.symbol_count-1].character,filestate.symbol_list[filestate.symbol_count-1].number);

    }

     close(fd);

}

_node*  creat_node( struct _symbol* s)

{

    _node* p;

    p =  malloc(sizeof(_node));

    p-> temp = s-> number;

    p-> symbol = s;

    p-> left =  NULL;

    p-> right =  NULL;

     return p;

}

_node*  creat_haffman( struct _filestate* filestate) //(未用优先队列实现)

{

    _node* parent =  NULL;

     unsigned  char i,j; //临时变量

    node_list = (_node**) malloc(filestate-> symbol_count*sizeof(_node*));

     for(i= 0;i<filestate-> symbol_count;i++)

    {   

        node_list[i] =  creat_node(&(filestate-> symbol_list[i]));

    }

     // printf("===================\n");

     // for(i=0;i<filestate.symbol_count;i++)

     // {    

     //  printf("%d %d %d\n",i,node_list[i]->symbol->character,node_list[i]->temp);

     // }

     unsigned  char minidx =  0;

     unsigned  char secidx =  0;

     for(i= 0;i<filestate-> symbol_count- 1;i++)

    {

        j= 0;

         while(!node_list[j])

        {

            j++;

        }

        minidx = j;

         for(j= 0;j<filestate-> symbol_count;j++)

        {

             if(node_list[j]!= NULL && node_list[j]-> temp < node_list[minidx]-> temp)

                minidx = j;

        }

         //printf("min:%d \n",node_list[minidx]->temp);

        j= 0;

         while(j==minidx || !node_list[j])

        {

            j++;

        }

        secidx = j;

         for(j= 0;j<filestate-> symbol_count;j++)

        {

             if(j!=minidx && node_list[j]!= NULL && node_list[j]-> temp < node_list[secidx]-> temp)

                secidx = j;

        }   

         //printf("sec:%d \n",node_list[secidx]->temp);

        parent =  malloc(sizeof(_node));

        parent-> temp = node_list[minidx]-> temp + node_list[secidx]-> temp;

        parent-> symbol =  NULL;

        parent-> left = node_list[minidx];

        parent-> right = node_list[secidx];

        node_list[minidx] = parent;

        node_list[secidx] =  NULL;

         //secidx = 0;

         // for(j=0;j<filestate.symbol_count;j++)

         // {

         //  if(node_list[j]!=NULL && node_list[j]->temp>node_list[minidx]->temp)

         //      secidx = j;

         // }    

    }

     // int a=0;

     // for(i=0;i<filestate.symbol_count;i++)

     // {

     //  if(node_list[i]!=NULL)a++,printf("%d\n",a);

     // }

     return parent;

}

void  compressing( char* filename)

{

     read_file(filename);

    root =  creat_haffman(&filestate); //创建哈夫曼树

     creat_dictionary(root);

     coding_file(filename); //将源文件转化为哈弗曼编码

     char* s =  find( 'u');

     printf( "%c %s\n", 'u',s);

}

char  findchar(_node* p, int fd, unsigned  char* t, int* f)

{

    (*f)--;

     if(*f< 1)

    {

         int r =  read(fd,t, 4);

         if(r< 0)  perror( " read error!");

         else  if(r== 0)

        {

             return - 1;

        }

        *f =  8;

    }

     if(p-> left== NULL&&p-> right== NULL)

         return p-> symbol-> character;

     if((*t>>*f)% 2)

             return  findchar(p-> right,fd,t,f);

     else  return  findchar(p-> left,fd,t,f);

}

void  jieya(_node* root, int fdr, int fdw)

{

     unsigned  char temp= 0;

     char ch;

     int flag=- 1;

     int r;

     _node* p =  NULL;

     // unsigned int te=0;

     // int gg=1;

     // char s[34]= "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.";

     // int f;

     while( 1)

    {

         if(flag< 0)

        {

            r =  read(fdr,&temp, 1);

             if(r< 0)  perror( " read error!");

             else  if(r== 0) return;

            flag =  7;

             // te = temp;

             // printf("%d..%d",gg,temp);

             // f = 31;

             // while(f+1)

             // {            

             //  s[f--] = (char)(te%2+48);

             //  te/=2;

             // }

             // printf(" %s\n",s);

        }

         // if((temp>>flag)%2)

         //  ch = findchar(root->right,temp,&flag);

         // else ch = findchar(root->left,temp,&flag);

         //  ch = findchar(root,fdr,&temp,&flag);

        p = root;

         while( 1)

        {

             if(flag< 0)

            {

                r =  read(fdr,&temp, 1);

                 if(r< 0)  perror( " read error!");

                 else  if(r== 0) return;

                flag =  7;

                 // te = temp;

                 // printf("%d..%d",gg,temp);

                 // f = 31;

                 // while(f+1)

                 // {            

                 //  s[f--] = (char)(te%2+48);

                 //  te/=2;

                 // }

                 // printf(" %s\n",s);

            }

             if(p-> left== NULL&&p-> right== NULL)

            {

                ch =  p-> symbol-> character;

                 //printf(" %c\n",ch);

                 break;

            }

             if((temp>>flag)% 2)

                p = p-> right,flag--;

             else p = p-> left,flag--;

        }

         if(( write(fdw,&ch, 1))< 0)  perror( "write.. error!"); 

    }

}

void  uncompressing( char* name)

{

     struct _filestate *f =  malloc(sizeof( struct _filestate));

     int r;

     int fdr =  open(name,O_RDONLY);

     if(fdr< 0)  perror( "openr error!");

     //读取文件头

     if(( read(fdr,f,sizeof( struct _filestate))< 0))  perror( "read error!");

     //创建哈弗曼树

    _node* root =  creat_haffman(f);

     char name2[ 20];

     int len =  strlen(name)- 5;

    name[len] =  0;

     sprintf(name2, "%s.ievv",name);

     printf( "%s\n",name2);

     int fdw =  open(name2,O_CREAT|O_WRONLY);

     if(fdw< 0)  perror( "openw errorint!");

     //printf("%d\n",fdw);

     //将读压缩文件,创建解压文件

     jieya(root,fdr,fdw);

}

int  main( int argc,  char  const *argv[])

{

     init();

    

     if(argv[ 1][ 0]== '-')

         if(argv[ 1][ 1]== 'y')

             compressing(( char*)argv[ 2]);

         else  if(argv[ 1][ 1]== 'j')

             uncompressing(( char*)argv[ 2]);

     else  printf( "input error\n");

     return  0;

}