大规模字符串检索-压缩trie树

本文使用压缩trie树实现字符串检索的功能。首先将字符串通过编码转化为二进制串，随后将二进制串插入到trie树中，在插入过程中同时实现压缩的功能。

字符编码采用Huffman，但最终测试发现不采用Huffman的方法不仅省下了编码时间，同时trie树的插入时间也有所减少。

 /**
     程序主函数与编码
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "huffman.h"
 #include "compress_trie.h"
 //#include <time.h>

 #define NUM_OF_HUFFMAN 81
 #define LENGTH_OF_LINE 10000
 #define RESULT_OF_HUFFMAN "result_of_HUFFMAN.dat"
 //#define EMAIL "strpool.dat"
 //#define CHECKED_EMAIL "checkedemail.dat"
 #define RESULT "result.dat"

 void str_to_bin(char buf[],char binary[],huffman_node hufm[]);

 int main(int argc, char *argv[])
 {
     //time_t time_start,time_end;
     //time_start = time(NULL);

     char* EMAIL = argv[];
     char* CHECKED_EMAIL = argv[];

     huffman_node hufm[NUM_OF_HUFFMAN];
     hufm_init(hufm,NUM_OF_HUFFMAN);
     char buf[LENGTH_OF_LINE];
     char binary[LENGTH_OF_LINE];

     FILE* fin_of_huffman;
     fin_of_huffman = fopen(RESULT_OF_HUFFMAN,"r");
     if(fin_of_huffman == NULL)
     {
         hufm_init(hufm,NUM_OF_HUFFMAN);
         int i;
         for(i=;i<(NUM_OF_HUFFMAN+)/;i++)
         {
             hufm[i].num_of_ch = NUM_OF_HUFFMAN - i;
         }
         huffman_coding(hufm,NUM_OF_HUFFMAN);
     }
     else
     {
         char temp_char;
         int i;
         for(i=;i<(NUM_OF_HUFFMAN+)/;i++)
         {
             fgets(buf,sizeof(buf),fin_of_huffman);
             sscanf(buf,"%c %d %s",&temp_char,&hufm[i].num_of_ch,hufm[i].code);
         }
     }
     fclose(fin_of_huffman);

     printf("building trie...");
     FILE* fin_of_email;
     fin_of_email = fopen(EMAIL,"r");
     trie_node *root;
     root = (trie_node*)malloc(sizeof(trie_node));
     trie_node_init(&root);

     while(fgets(buf,sizeof(buf),fin_of_email)!=NULL)
     {
         str_to_bin(buf,binary,hufm);
         trie_insert(&root,binary);
     }
     fclose(fin_of_email);
     printf("\r");
     printf("build trie success.\n");

     FILE *fin_of_checked,*fout_of_result;
     fin_of_checked = fopen(CHECKED_EMAIL,"r");
     fout_of_result = fopen(RESULT,"w");
     int num_yes = ;
     int num_no = ;
     while(fgets(buf,sizeof(buf),fin_of_checked)!=NULL)
     {
         str_to_bin(buf,binary,hufm);
         if(trie_search(root,binary))
         {
             fprintf(fout_of_result,"YES\n");
             num_yes++;
         }
         else
         {
             fprintf(fout_of_result,"NO\n");
             num_no++;
         }
     }
     fprintf(fout_of_result,"num of YES is:%d\n",num_yes);
     fprintf(fout_of_result,"num of NO is:%d\n",num_no);
     printf("search success!\n");
     fclose(fin_of_checked);
     fclose(fout_of_result);
     //time_end = time(NULL);
     //printf("用时：%.0lfs\n", difftime(time_end, time_start));
     return ;
 }

 void str_to_bin(char buf[],char binary[],huffman_node hufm[])
 {
     int i;
     binary[] = '\0';
     for(i=strlen(buf)-;i>=;i--)
     {
         if(buf[i]>='a' && buf[i]<='z')
         {
             strcat(binary,hufm[buf[i]-'a'].code);
         }
         else if(buf[i]>='A' && buf[i]<='Z')
         {
             strcat(binary,hufm[buf[i]-'A'].code);
         }
         else if(buf[i]>='' && buf[i]<='')
         {
             strcat(binary,hufm[+buf[i]-''].code);
         }
         else if(buf[i]=='_')
         {
             strcat(binary,hufm[].code);
         }
         else if(buf[i]=='-')
         {
             strcat(binary,hufm[].code);
         }
         else if(buf[i]=='.')
         {
             strcat(binary,hufm[].code);
         }
         else if(buf[i]=='@')
         {
             strcat(binary,hufm[].code);
         }
         else
         {
             strcat(binary,hufm[].code);
         }
     }
 }

 /**
     完成trie树的插入，查找。
 */

 typedef struct TRIE_NODE
 {
     char is_str;
     unsigned short num_of_bit;
     unsigned char* compress_of_bit;
     struct TRIE_NODE *point_of_zero,*point_of_one;
 }trie_node;

 //long int temp_of_new = 0;

 void trie_node_init(trie_node **root);
 int trie_insert(trie_node **root,char* bit_of_insert);
 int trie_search(trie_node *root,char* bit_of_insert);
 void trie_delete(trie_node *root);
 void compress(trie_node *root,char* bit_of_insert);
 int compare_of_bit(trie_node *root,char* bit_of_insert);
 void pop_bit(trie_node *root,char* bit_of_pop,int len_of_pop);

 void trie_node_init(trie_node **root)
 {
     (*root)->is_str = (char);
     (*root)->num_of_bit = ;
     (*root)->compress_of_bit = NULL;
     (*root)->point_of_zero = NULL;
     (*root)->point_of_one = NULL;
 }

 void compress(trie_node *root,char* bit_of_insert)
 {
     int i,j,len_of_insert;
     len_of_insert = strlen(bit_of_insert);
     root->num_of_bit = len_of_insert;
     if(root->num_of_bit<=)
     {
         int temp;
         for(i=len_of_insert-,j=;i>=;i--,j++)
         {
             if(bit_of_insert[i] == '')
             {
                 clearbit(temp,j);
             }
             else
             {
                 setbit(temp,j);
             }
         }
         root->compress_of_bit = (unsigned char*)temp;
     }
     else
     {
         root->compress_of_bit = (unsigned char*)malloc((len_of_insert%)?(len_of_insert/+):(len_of_insert/));
         for(i=len_of_insert-,j=;i>=;i--,j++)
         {
             if(bit_of_insert[i] == '')
             {
                 clearbit(root->compress_of_bit[j/],j%);
             }
             else
             {
                 setbit(root->compress_of_bit[j/],j%);
             }
         }
     }
 }

 int trie_insert(trie_node **root,char* bit_of_insert)
 {
     int ret;
     char bit_of_pop[];
     if(root == NULL)
     {
         ret = ;
     }
     else
     {
         if((*root)->num_of_bit == )
         {
             if(!(*bit_of_insert))
             {
                 (*root)->is_str = (char);
                 ret = ;
             }
             else
             {
                 if((*root)->is_str ==
                    && (*root)->point_of_zero == NULL
                    && (*root)->point_of_one == NULL)
                 {
                     compress((*root),bit_of_insert);
                     (*root)->is_str = (char);
                     ret = ;
                 }
                 else
                 {
                     if(*bit_of_insert == '')
                     {
                         if((*root)->point_of_zero == NULL)
                         {
                             (*root)->point_of_zero = (trie_node*)malloc(sizeof(trie_node));
                             trie_node_init(&(*root)->point_of_zero);
                             //temp_of_new++;
                         }
                         ret = trie_insert(&(*root)->point_of_zero,bit_of_insert+);
                     }
                     else
                     {
                         if((*root)->point_of_one == NULL)
                         {
                             (*root)->point_of_one = (trie_node*)malloc(sizeof(trie_node));
                             trie_node_init(&(*root)->point_of_one);
                             //temp_of_new++;
                         }
                         ret = trie_insert(&(*root)->point_of_one,bit_of_insert+);
                     }
                 }
             }
         }
         else
         {
             int ans_of_compare = compare_of_bit((*root),bit_of_insert);
             if(ans_of_compare == )
             {
                 trie_node *father = (trie_node*)malloc(sizeof(trie_node));
                 trie_node_init(&father);
                 //temp_of_new++;
                 pop_bit((*root),bit_of_pop,);
                 if(bit_of_pop[] == '')
                 {
                     father->point_of_zero = (*root);
                 }
                 else
                 {
                     father->point_of_one = (*root);
                 }
                 if(!(*bit_of_insert))
                 {
                     father->is_str = (char);
                     ret = ;
                 }
                 else
                 {
                     if(*bit_of_insert == '')
                     {
                         father->point_of_zero = (trie_node*)malloc(sizeof(trie_node));
                         trie_node_init(&father->point_of_zero);
                         //temp_of_new++;
                         ret = trie_insert(&father->point_of_zero,bit_of_insert+);
                     }
                     else
                     {
                         father->point_of_one = (trie_node*)malloc(sizeof(trie_node));
                         trie_node_init(&father->point_of_one);
                         //temp_of_new++;
                         ret = trie_insert(&father->point_of_one,bit_of_insert+);
                     }
                 }
                 (*root) = father;
             }
             else
             {
                 if(ans_of_compare == (int)(*root)->num_of_bit
                    && ans_of_compare == strlen(bit_of_insert))
                 {
                     (*root)->is_str = (char);
                     ret = ;
                 }
                 else if(ans_of_compare == (int)(*root)->num_of_bit)
                 {
                     bit_of_insert += ans_of_compare;
                     if(*bit_of_insert == '')
                     {
                         if((*root)->point_of_zero == NULL)
                         {
                             (*root)->point_of_zero = (trie_node*)malloc(sizeof(trie_node));
                             trie_node_init(&(*root)->point_of_zero);
                             //temp_of_new++;
                         }
                         ret = trie_insert(&(*root)->point_of_zero,bit_of_insert+);
                     }
                     else
                     {
                         if((*root)->point_of_one == NULL)
                         {
                             (*root)->point_of_one = (trie_node*)malloc(sizeof(trie_node));
                             trie_node_init(&(*root)->point_of_one);
                             //temp_of_new++;
                         }
                         ret = trie_insert(&(*root)->point_of_one,bit_of_insert+);
                     }
                 }
                 else if(ans_of_compare == strlen(bit_of_insert))
                 {
                     trie_node *father = (trie_node*)malloc(sizeof(trie_node));
                     trie_node_init(&father);
                     //temp_of_new++;
                     pop_bit((*root),bit_of_pop,ans_of_compare);
                     compress(father,bit_of_pop);
                     father->is_str = (char);
                     pop_bit((*root),bit_of_pop,);
                     if(bit_of_pop[] == '')
                     {
                         father->point_of_zero = (*root);
                     }
                     else
                     {
                         father->point_of_one = (*root);
                     }
                     (*root) = father;
                 }
                 else
                 {
                     trie_node *father = (trie_node*)malloc(sizeof(trie_node));
                     trie_node_init(&father);
                     //temp_of_new++;
                     pop_bit((*root),bit_of_pop,ans_of_compare);
                     compress(father,bit_of_pop);
                     pop_bit((*root),bit_of_pop,);
                     bit_of_insert += ans_of_compare+;

                     if(bit_of_pop[] == '')
                     {
                         father->point_of_zero = (*root);
                         father->point_of_one = (trie_node*)malloc(sizeof(trie_node));
                         trie_node_init(&father->point_of_one);
                         //temp_of_new++;
                         ret = trie_insert(&father->point_of_one,bit_of_insert);
                     }
                     else
                     {
                         father->point_of_one = (*root);
                         father->point_of_zero = (trie_node*)malloc(sizeof(trie_node));
                         trie_node_init(&father->point_of_zero);
                         //temp_of_new++;
                         ret = trie_insert(&father->point_of_zero,bit_of_insert);
                     }
                     (*root) = father;
                 }
             }
         }
     }
     return ret;
 }

 int trie_search(trie_node *root,char *bit_of_search)
 {
     trie_node *p = root;
     while(p!=NULL && *bit_of_search)
     {
         if(p->num_of_bit!=)
         {
             if((int)p->num_of_bit == compare_of_bit(p,bit_of_search))
             {
                 bit_of_search += (int)p->num_of_bit;
             }
             else
             {
                 p=NULL;
                 break;
             }
         }
         if(!(*bit_of_search))
         {
             break;
         }
         if(bit_of_search[]=='')
         {
             p = p->point_of_zero;
             bit_of_search++;
         }
         else if(bit_of_search[]=='')
         {
             p = p->point_of_one;
             bit_of_search++;
         }
         if(!(*bit_of_search) && p!=NULL && p->num_of_bit!=)
         {
             p=NULL;
             break;
         }
     }
     if(p!=NULL)
     {
         return p->is_str;
     }
     else
     {
         return ;
     }
 }

 void trie_delete(trie_node *root)
 {
     if(root == NULL)
         return;
     trie_delete(root->point_of_zero);
     trie_delete(root->point_of_one);
     free(root);
 }

 int compare_of_bit(trie_node *root,char* bit_of_insert)
 {
     int len_of_insert = strlen(bit_of_insert);
     int i,j,tempbit;
     if(root->num_of_bit<=)
     {
         for(i=,j=root->num_of_bit-;i<len_of_insert && i<root->num_of_bit;i++,j--)
         {
             tempbit = getbit((int)root->compress_of_bit,j);
             if(bit_of_insert[i]-'' != tempbit)
             {
                 break;
             }
         }
     }
     else
     {
         for(i=,j=root->num_of_bit-;i<len_of_insert && i<root->num_of_bit;i++,j--)
         {
             tempbit = getbit(root->compress_of_bit[j/],j%);
             if(bit_of_insert[i]-'' != tempbit)
             {
                 break;
             }
         }
     }
     return i;
 }

 void pop_bit(trie_node *root,char* bit_of_pop,int len_of_pop)
 {
     int i,j;
     short num_of_bit = root->num_of_bit - (short)len_of_pop;
     if(root->num_of_bit<=)
     {
         for(i=,j=root->num_of_bit-;i<len_of_pop;i++,j--)
         {
             bit_of_pop[i] = getbit((int)root->compress_of_bit,j) +'';
         }
         bit_of_pop[i] = '\0';
     }
     else
     {
         for(i=,j=root->num_of_bit-;i<len_of_pop;i++,j--)
         {
             bit_of_pop[i] = getbit(root->compress_of_bit[j/],j%) +'';
         }
         bit_of_pop[i] = '\0';

         if(num_of_bit == )
         {
             free(root->compress_of_bit);
         }
         else if(num_of_bit<=)
         {
             int temp;
             for(j=num_of_bit-;j>=;j--)
             {
                 if(getbit(root->compress_of_bit[j/],j%) == )
                 {
                     clearbit(temp,j);
                 }
                 else
                 {
                     setbit(temp,j);
                 }
             }
             free(root->compress_of_bit);
             root->compress_of_bit = (unsigned char*)temp;
         }
         else
         {
             unsigned char *p;
             short num_of_byte = (num_of_bit%)?(num_of_bit/+):(num_of_bit/);
             if(((root->num_of_bit%)?(root->num_of_bit/+):(root->num_of_bit/)) != num_of_byte)
             {
                 p = (unsigned char*)malloc(num_of_byte);
                 short i;
                 for(i=;i<num_of_byte;i++)
                 {
                     p[i] = root->compress_of_bit[i];
                 }
                 free(root->compress_of_bit);
                 root->compress_of_bit = p;
             }
         }
     }
     root->num_of_bit = num_of_bit;
 }