[C] 哈夫曼算法

来源：网络

#include <stdio.h> 
#include <malloc.h> 
#include <conio.h> 
#include <stdlib.h> 
#include <string.h> 

/*声明两种链表结构----start*/ 
struct node_a{    /*链表1-----作用：用来统计文件中字符的个数和种类（通过count）*/ 
    char data; 
    int count; 
    struct node_a *next; 
}; 
typedef struct node_a node,*list; 
list head=NULL; 

struct nodeb{    /*链表2-----作用：用来建立用相应的编码代替字符的新文件*/ 
    char data; 
    struct nodeb *next; 
}; 
typedef struct nodeb node_b,*list_b;    /*jiang bianma xieru wenjian*/ 
list_b head_b=NULL; 
/*声明两种链表结构----end*/ 

/*哈夫曼算法种相关的3种结构的声明-----start*/ 
struct forest{     
    float weight; 
    int root; 
}; 
struct alphabet{ 
    char symbol; 
    float probability; 
    int leaf; 
    char *bianma;             
}; 
struct tree{ 
    int lchild; 
    int rchild; 
    int parent; 
}; 
typedef struct tree *tree_ptr,tree_node; 
typedef struct forest *forest_ptr,forest_node; 
typedef struct alphabet *alphabet_ptr,alphabet_node; 
tree_ptr tree1; 
forest_ptr forest1; 
alphabet_ptr alphabet1; 
int lasttree,lastnode; 
int least,second; 
/*哈夫曼算法种相关的3种结构的声明-----end*/ 

/**************stack difination start****************/ 
struct stacknode{ 
    char *bian_ma; 
    struct stacknode *next; 
}; 
typedef struct stacknode stack_node; 
typedef stack_node *link; 
link top=NULL; 

void push(char *item){ 
    link p; 
    if(top!=NULL){ 
        p=(link)malloc(sizeof(stack_node)); 
        if(p==NULL){ 
           printf("Memory allocation error!"); 
           return; 
        } 
        p->bian_ma=item; 
        p->next=top; 
        top=p; 
    }
    else{ 
        top=(link)malloc(sizeof(stack_node)); 
        if(!top){ 
            printf("Memory allocation error!"); 
            return; 
        } 
        top->bian_ma=item; 
        top->next=NULL; 
    } 
 } 

void pop(void){ 
    link p; 
    p=top; 
    top=top->next; 
    free(p); 
} 

void makenull(void){ 
    while(top!=NULL) 
        pop(); 
} 

int empty(){ 
    if(top==NULL) 
       return 1; 
    else 
       return 0; 
} 

char* tops(void){ 
     return (top->bian_ma); 
} 

void display_stack(link s){ /*显示栈重的内容*/ 
    link ptr; 
    ptr=s; 
    while(ptr!=NULL){ 
        printf("%s",ptr->bian_ma); 
        ptr=ptr->next; 
    } 
} 

/***************************stack__difination is end************************/ 
void display(list h){ /*显示链表1*/ 
    list ptr; 
    int i=1; 
    ptr=h->next; 
    while(ptr!=NULL){ 
        printf("%d,%c,%d\n",i,ptr->data,ptr->count); 
        i++; 
        ptr=ptr->next; 
    } 
} 
void display_b(list_b h){    /*显示链表2*/ 
    list_b ptr; 
    int i=1; 
    ptr=h->next; 
    while(ptr!=NULL){ 
        printf("%d,%c\n",i,ptr->data); 
        i++; 
        ptr=ptr->next; 
    } 
} 

void insert(char item){    /*用于插入元素以建立链表1*/ 
     list temp,ptr; 
     int flag; 
     ptr=head->next; 
     if(ptr==NULL){ 
         head->next=(list)malloc(sizeof(node)); 
         head->next->data=item; 
         head->next->count=1; 
         head->next->next=NULL; 
     } 
     else{ 
         while(ptr!=NULL){ 
             if(ptr->data==item){ 
                 ptr->count=ptr->count+1; 
                 flag=1; 
             } 
             ptr=ptr->next; 
         } 
         ptr=head; 
         if(flag==1) 
             return; 
         else{ 
             temp=ptr->next; 
             ptr->next=(list)malloc(sizeof(node)); 
             ptr->next->data=item; 
             ptr->next->count=1; 
             ptr->next->next=temp; 
         } 
    } 
} 

void insert_b(char item){    /*插入元素以建立链表2*/ 
    list_b ptr_b, temp_b; 
    ptr_b=head_b; 
    if(ptr_b->next==NULL){ 
        head_b->next=(list_b)malloc(sizeof(node_b)); 
        head_b->next->data=item; 
        head_b->next->next=NULL; 
    } 
    else{ 
        while(ptr_b->next!=NULL){ 
            ptr_b=ptr_b->next; 
        } 
        ptr_b->next=(list_b)malloc(sizeof(node_b)); 
        ptr_b->next->data=item; 
        ptr_b->next->next=NULL; 
    } 
} 

void search(void){ /*搜索文件并将文件中的数据分别存入作用不同的链表中*/ 
    FILE *fp; 
    list ptr; 
    char ch; 
    if((fp=fopen("test.txt","r"))==NULL) 
         printf("Reading error!\n"); 
    while(!feof(fp)){ 
        ch=getc(fp); 
        if(ferror(fp)){ 
            printf("error!\n"); 
            break; 
        } 
        if(ch==EOF) 
            break; 
        insert(ch);     /*插入元素进链表1*/ 
        insert_b(ch); /*插入元素进链表2*/ 
    } 
    printf("\n"); 
    fclose(fp); 
} 

void display_struct(int n){ /*显示哈夫曼算法中的3个结构树组 */ 
    int i=0; 
    printf("\n\n=======================================\n\n"); 
    printf("FOREST_STRUCT_ARRY :\n\n\n"); 
    for(i=0;i<=n;i++){ 
        printf("%f,%d\n",forest1[i].weight,forest1[i].root); 
    } 
    getch(); 
    printf("\n\nALPHABET_STRUCT_ARRY :\n\n\n"); 
    for(i=0;i<=n;i++){ 
        printf("%f,%d,%c\n",alphabet1[i].probability,alphabet1[i].leaf,alphabet1[i].symbol); 
    } 
    getch(); 
    printf("\n\nTREE_STRUCT_ARRY :\n\n\n"); 
    for(i=0;i<=2*n-1;i++) 
        printf("%d,%d,%d\n",tree1[i].lchild,tree1[i].rchild,tree1[i].parent); 
    printf("\n\n======================================\n\n"); 
    getch(); 
} 

int init_struct(void){    /*初始化哈夫曼算法中3种结构数组*/ 
    list ptr; 
    float count=.0; 
    int i=1,n=0; 
    ptr=head->next; 
    while(ptr!=NULL){ 
        count=ptr->count+count; 
        n++; 
        ptr=ptr->next; 
    } 
    ptr=head->next; 
    forest1=(forest_ptr)malloc(sizeof(forest_node)*n+sizeof(forest_node)); 
    alphabet1=(alphabet_ptr)malloc(sizeof(alphabet_node)*n+sizeof(alphabet_node)); 
    tree1=(tree_ptr)malloc(sizeof(tree_node)*n*2-sizeof(tree_node)); 
    forest1[0].weight=alphabet1[0].probability=0.0; 
    forest1[0].root=alphabet1[0].leaf=0; 
    alphabet1[0].symbol='0'; 
    while(ptr!=NULL){ 
        forest1[i].weight=alphabet1[i].probability=ptr->count/count; 
        forest1[i].root=alphabet1[i].leaf=i; 
        alphabet1[i].symbol=ptr->data; 
        i++; 
        ptr=ptr->next; 
    } 
    for(i=0;i<=2*n-1;i++){ 
        tree1[i].lchild=0; 
        tree1[i].rchild=0; 
        tree1[i].parent=0; 
    } 
    return n; 
} 

void creat(void){            /*创建正文文件test.txt*/ 
    FILE *fp,*out; 
    char ch; 
    if((fp=fopen("test.txt","r++"))==NULL) 
        printf("Creat error!\n"); 
    printf("Input the data:\n"); 
    ch=getch(); 
    putch(ch); 
    while(ch!='#'){ 
        putc(ch,fp); 
        ch=getch(); 
        putch(ch); 
    } 
    fclose(fp); 
} 

void creat_bianma(int number){    /*根据哈夫曼算法建立文件中各种字符对应的编码*/ 
    int i,j,n; 
    int p; 
    char *bm=malloc(sizeof(char)*number); 
    for(n=1;n<=number;n++){ 
        j=i=n; 
        makenull(); 
        p=tree1[i].parent; 
        while(tree1[p].parent!=0){ 
            if(tree1[p].lchild==i) 
                push("0"); 
            else 
                push("1"); 
            i=p; 
            p=tree1[p].parent; 
        } 

        if(tree1[p].lchild==i) 
            push("0"); 
        else 
            push("1"); 
        strcpy(bm," "); /*目的：使创建编码文件中的各编码中间存在间隔*/ 
        while(!empty()){ 
            strcat(bm,tops()); 
            pop(); 
        } 
        alphabet1[j].bianma=malloc(sizeof(char)*number); 
        strcpy(alphabet1[j].bianma,bm); 
        printf("\n%c:%s",alphabet1[j].symbol,alphabet1[j].bianma); /*打印出相应的编码*/ 
        getch(); 
    } 
} 


void write_new_file(int number){ /*根据相应的编码重新建立编码文件*/ 
    FILE *fp; 
    list_b ptr; 
    int i; 
    char *ch=malloc(sizeof(char)*number); 
    ptr=head_b->next; 
    if((fp=fopen("bianma.txt","w"))==NULL) 
        printf("Write in a new file error!"); 
    else{ 
        while(ptr!=NULL){ 
            for(i=1;i<=number;i++){ 
                if(ptr->data==alphabet1[i].symbol){ 
                    strcpy(ch,alphabet1[i].bianma); 
                    fputs(ch,fp); 
                } 
            } 
            ptr=ptr->next; 
        } 
    } 
    fclose(fp); 
} 


void main(void){ 
    int i,num; 
    char ch; 
    void huffman(void); 
    void lightones(); 
    head=(list)malloc(sizeof(node)); 
    head->next=NULL; 
    head->data='\0'; 
    head->count=0; 
    head_b=(list_b)malloc(sizeof(node_b)); 
    head_b->data='\0'; 
    head_b->next=NULL; 
    do{ 
        system("cls"); 
        creat(); 
        search(); 
        printf("\nlianbiao1:\n"); 
        display(head);/*显示链表1*/ 
        getch(); 
        printf("\nlianbiao2:\n"); 
        display_b(head_b); 
        getch(); 
        num=init_struct(); 
        printf("\n"); 
        printf("The 3 init_struct of huffman?\n"); 
        display_struct(num);/*显示初始化的哈夫曼书的相关3个结构数组*/ 
        lastnode=num; 
        lasttree=num; 
        huffman(); 
        printf("Now the 3 struct through huffman shuanfa\n"); 
        display_struct(num);/*显示哈夫曼树中相关的3种结构（经过哈夫曼算法处理）*/ 
        printf("\nThe bian_ma is:\n"); 
        creat_bianma(num); 
        write_new_file(num); 
        printf("\nDo you want to re_try(y/n)?"); 
        ch=getchar(); 
    }while(ch=='y'); 
} 

/*哈夫曼算法-----defination_start*/ 
void lightones(void){ 
    int i; 
    if(forest1[1].weight<=forest1[2].weight){ 
        least=1; 
        second=2; 
    } 
    else{ 
        least=2; 
        second=1; 
    } 
    for(i=3;i<=lasttree;i++) 
        if(forest1[i].weight<forest1[least].weight){ 
        second=least; 
        least=i; 
    } 
    else 
        if(forest1[i].weight<forest1[second].weight) 
            second=i; 
} 

int creat_tree(int lefttree,int righttree){ 
    lastnode=lastnode+1; 
    tree1[lastnode].lchild=forest1[lefttree].root; 
    tree1[lastnode].rchild=forest1[righttree].root; 
    tree1[lastnode].parent=0; 
    tree1[forest1[lefttree].root].parent=lastnode; 
    tree1[forest1[righttree].root].parent=lastnode; 
    return(lastnode); 
} 

void huffman(void){ 
    int i,j; 
    int newroot; 
    while(lasttree>1){ 
        lightones(); 
        i=least; 
        j=second; 
        newroot=creat_tree(i,j); 
        forest1[i].weight=forest1[i].weight+forest1[j].weight; 
        forest1[i].root=newroot; 
        forest1[j]=forest1[lasttree]; 
        lasttree=lasttree-1; 
    } 
}