C++하프 만 트 리 파일 압축,암호 화 구현 코드

예전 에 LZW 압축 알고리즘 을 쓸 때 힘 든 문제 가 많 았 습 니 다.대체적으로 하 프 만 코드 에서 해결 되 었 습 니 다.이 코드 를 쓰 는 데 신경 을 많이 썼 지만 코드 를 완전한 코드 로 만 들 었 습 니 다.하 프 만 이라는 사상 이 정말 강하 기 때 문 입 니 다.하프 만 트 리 는 당시 에 제 가 LZW 서열 화 할 때 해결 하고 싶 었 던 문 제 를 교묘 하 게 해 결 했 습 니 다.바로 압축 된 텍스트 의 분할 입 니 다.예 를 들 어 lzw 로 abc 를 인 코딩 하면 1,2,3 이다.그러나 이것 은 파일 로 저장 할 때 반드시 분할 문자 로 1,2,3 을 분할 해 야 하 며 공간 을 매우 낭비 해 야 한다.그렇지 않 으 면 12,23,123 과 이의 성 이 생 길 수 있다.한편,하 프 만 나 무 는 모든 char 를 잎 노드 에 분포 시 켰 다.복원 할 때 예 를 들 어 1101110,110 이 잎 노드 라 고 가정 하면 110 까지 갔 을 때 확인 할 수 있다.이미 끝 에 이 르 렀 고 뿌리 노드 로 돌아 가 계속 걸 어가 면 문자 의 분할 을 피 할 수 있다.모두 10101010101001 과 같은 경로 로 문 자 를 표시 하고 8 자 리 를 1 개의 char 로 압축 하여 저장 할 수 있다.나 무 를 구성 할 때 나타 나 는 확률 이 높 은 char 를 위 에 올 려 놓 으 면 경로 가 짧 고 자 연 스 럽 게 저장 공간 을 절약 할 수 있다.하 프 만 의 압축 효율 이 가장 높 은 것 은 아니 지만 낙관적 인 편 이다.
하 프 만 은 압축 을 제외 하고 암호 화 에 도 사용 할 수 있 습 니 다.텍스트 를 하 프 만 으로 인 코딩 할 때 지속 적 으로 생 성 된 char 계수 링크 구 조 를 사용 해 야 트 리 구 조 를 복원 할 수 있 습 니 다.디 코딩 할 때 경 로 는 바로 트 리 구조 에 의존 합 니 다.즉,이러한 인 코딩 은 약 정 된 형식의 인 코딩 으로 인 코딩 할 때 원문 으로 트 리 구 조 를 만 들 고 트 리 경 로 를 저장 합 니 다.디 코딩 할 때 트 리 가 부족 하거나 트 리 구조 가 원래 와 일치 하지 않 으 면 디 코딩 을 완성 할 수 없습니다.예 를 들 어 제 가 10 으로 a 를 대표 하고 10 을 저장 하 는 것 은 10 입 니 다.10 을 b 또는 c 로 해석 하 는 것 은 모두 정확 하지 않 습 니 다.char 저장 소 로 전환 하기 때문에 마지막 으로 채 워 진 수량,텍스트 길 이 를 지속 적 으로 유지 해 야 원래 01 표 시 된 텍스트 형식 을 복원 할 수 있 습 니 다.
이 코드 는 어느 정도 결함 이 있 습 니 다.그 당시 에 텍스트 를 처리 하 는 것 을 고려 했 기 때문에 파일 에 char='\0'이 있 을 때 오류 가 발생 할 수 있 습 니 다.이 코드 는 신경 을 많이 써 서 계속 복구 하지 않 았 습 니 다.필요 하 다 면 스스로 변경 할 수 있 고 해결 방법 이 많 을 것 입 니 다.
먼저 실행 그림 을 보 여 줍 니 다:

소스 코드

#include<iostream> 
#include<sstream> 
#include<fstream> 
 
void WriteFile(char* path,const char* content,int length,bool append=false); 
using namespace std; 
struct Node{  
  char data; 
  Node* left; 
  Node* right;  
}; 
 
struct L_Node{ 
  int count; 
  Node* node; 
  L_Node* next; 
}; 
 
Node* AddNode(int count,char data,L_Node*& first){ 
  L_Node* lnode=new L_Node(); 
  lnode->count=count; 
  Node* node=new Node(); 
  node->data=data; 
  node->left=0; 
  node->right=0; 
  lnode->node=node; 
  if(first==0){ 
    first=lnode; 
  } 
  else{ 
    if(lnode->count<first->count){ 
      lnode->next=first; 
      first=lnode; 
    } 
    else{ 
      L_Node* iter=first; 
       
      while(iter->next!=0&&iter->next->count<lnode->count){ 
        iter=iter->next; 
      } 
       
      if(iter->next==0){ 
        iter->next=lnode; 
        lnode->next=0; 
      } 
      else{ 
        lnode->next=iter->next; 
        iter->next=lnode; 
      } 
    } 
  } 
  return node; 
} 
 
void SaveLNodes(L_Node* first){ 
  stringstream ss; 
  while(first!=0){ 
    ss<<(int)(unsigned char)first->node->data<<':'<<first->count<<' '; 
    first=first->next; 
  } 
  WriteFile("nodes.txt",ss.str().c_str(),ss.str().length()); 
} 
 
void GetLNodes(L_Node*& first){ 
  char temp[32]; 
  ifstream in; 
  in.open("nodes.txt",ios::in|ios::binary); 
  while(!in.eof()){ 
    temp[0]=0; 
    in>>temp; 
    if(strlen(temp)>0){ 
      char* data=strtok(temp,":"); 
      char* count=strtok(0,":"); 
      AddNode(atoi(count),atoi(data),first); 
    } 
     
  } 
} 
 
void BuildSortedList(char* content,L_Node*& first,int length){ 
  int array[256]={ 
    0 
  }; 
 
  for(int i=0;i<length;i++){ 
    array[(unsigned char)content[i]]++; 
  } 
 
  for(int i=0;i<256;i++){ 
    if(array[i]>0){ 
      AddNode(array[i],(char)i,first); 
    } 
  } 
  SaveLNodes(first); 
} 
 
void BuildTree(L_Node*& first,Node*& root){//get l1->node,l2->node,remove l1,l2,then put l3 into list,then set l3->left and l3->right 
  if(first->next==0){ 
    Node* node=new Node(); 
    root=node; 
    root->right=0; 
    node=new Node(); 
    node->data=first->node->data; 
    node->left=0; 
    node->right=0; 
    root->left=node; 
    delete first; 
    return; 
  } 
      
  while(first->next!=0){ 
    int count=first->count+first->next->count; 
    Node* node1=first->node; 
    L_Node* temp=first; 
    first=first->next; 
    delete temp; 
    Node* node2=first->node; 
    temp=first; 
    delete temp; 
    first=first->next; 
    root=AddNode(count,0,first); 
    root->left=node1; 
    root->right=node2; 
    //cout<<(int)node1->data<<':'<<(int)node2->data<<endl; 
  } 
  delete first; 
} 
 
void PreOrderTraversal(Node* node,char* track,int branch,char** table){ 
  if(node!=0){ 
     
    char* track2=0; 
     
    if(branch==0){ 
      track2=new char[strlen(track)+2]; 
      sprintf(track2,"%s0\0",track); 
    } 
    else if(branch==1){ 
      track2=new char[strlen(track)+2]; 
      sprintf(track2,"%s1\0",track); 
    } 
    else{ 
      track2=new char[strlen(track)+1]; 
      sprintf(track2,"%s\0",track); 
    } 
   
    if(node->data!=0){ 
      table[(unsigned char)node->data]=track2; 
    } 
     
    PreOrderTraversal(node->left,track2,0,table); 
    PreOrderTraversal(node->right,track2,1,table); 
     
   
    if(node->data==0){ 
      delete track2; 
    } 
  } 
} 
 
void PreOrderTraversal(Node* node){ 
  if(node!=0){ 
    cout<<(int)(unsigned char)node->data<<endl; 
    PreOrderTraversal(node->left); 
    PreOrderTraversal(node->right); 
  } 
} 
 
char* Encode(const char* content,char** table,int length){ 
   
  stringstream ss; 
 
  for(int i=0;i<length;i++){ 
    if((unsigned char)content[i]==0){ 
 
    } 
    else{ 
      ss<<table[(unsigned char)content[i]];  
    } 
  } 
   
   
  char* encoded_content=new char[ss.str().length()+1]; 
  memcpy(encoded_content,ss.str().c_str(),ss.str().length()); 
  encoded_content[ss.str().length()]=0; 
  return encoded_content; 
} 
 
int BinToDec(char* bin_content){ 
  int number=0; 
  int cur=1;  
  for(int i=7;i>=0;i--){ 
    number+=(bin_content[i]-'0')*cur; 
    cur*=2; 
  } 
  return number; 
}  
 
char* BinToCharText(const char* bin_content,int& fill_count,int& save_length){ 
  int length=strlen(bin_content); 
   
  fill_count=8-length%8; 
 
  if(fill_count>0){ 
    char* temp=new char[length+fill_count+1]; 
     
    char temp1[fill_count]; 
    for(int i=0;i<fill_count;i++){ 
      temp1[i]='0'; 
    } 
     
    sprintf(temp,"%s%s",bin_content,temp1); 
    temp[length+fill_count]=0; 
    bin_content=temp; 
  } 
   
  length+=fill_count; 
   
  save_length=length/8; 
 
  char* text=new char[length/8+1]; 
  for(int i=0;i<length;i+=8){ 
    char temp[8]; 
    memcpy(temp,bin_content+i,8); 
    text[i/8]=(char)BinToDec(temp); 
    
  } 
  text[length/8]=0; 
   
  if(fill_count>0){ 
    delete bin_content; 
  } 
   
  return text; 
} 
 
char* DecToBin(int num){ 
  char* bin=new char[8]; 
  if(num<0){ 
    num=256+num; 
  } 
   
  for(int i=7;i>=0;i--){ 
    bin[i]=num%2+'0'; 
    num/=2; 
  } 
  return bin; 
} 
 
char* CharTextToBin(char* text,int fill_count,int save_length){ 
  int length=save_length; 
 
  char* content=new char[8*length+1]; 
   
  int pos=0; 
  for(int i=0;i<length;i++){ 
    int number=text[i]; 
    char* bin=DecToBin(number); 
    memcpy(content+pos,bin,8); 
    pos+=8; 
    delete bin; 
  } 
   
  content[8*length-fill_count]=0; 
 
  return content; 
} 
 
char* Decode(const char* encode_content,Node* tree){ 
  stringstream ss; 
  Node* node=tree; 
 
  for(int i=0;i<strlen(encode_content);i++){ 
    if(encode_content[i]=='0'){ 
      node=node->left; 
    } 
    else if(encode_content[i]=='1'){ 
      node=node->right; 
    } 
 
    if(node->data!=0){ 
      ss<<node->data; 
      node=tree; 
    } 
  } 
  char* decode_content=new char[ss.str().length()+1]; 
  memcpy(decode_content,ss.str().c_str(),ss.str().length()); 
  decode_content[ss.str().length()]=0; 
  return decode_content; 
} 
 
 
void ReleaseTable(char** table){ 
  for(int i=0;i<256;i++){ 
    if(table[i]!=0){ 
      delete table[i]; 
    } 
  } 
} 
 
void PostOrderTraversal(Node* node){ 
  if(node!=0){ 
    PostOrderTraversal(node->left); 
    PostOrderTraversal(node->right); 
    delete node; 
  } 
}  
 
char* ReadFile(char* path,long& length){ 
  char* content=0; 
  ifstream in; 
  in.open(path,ios::in|ios::binary); 
  in.seekg(0,ios::end); 
  length=in.tellg(); 
  content=new char[length+1]; 
  in.seekg(0,ios::beg); 
  int i=0; 
  while(!in.eof()){ 
    content[i++]=in.get(); 
  } 
  content[length]=0; 
  in.close(); 
  return content; 
} 
 
char* ReadFile(char* path,int& fill_count,int& save_length){ 
  char* content=0; 
  ifstream in; 
  in.open(path,ios::in|ios::binary); 
  in>>fill_count>>save_length; 
  long cur=in.tellg()+(long)1; 
  in.seekg(0,ios::end); 
  long length=in.tellg()-cur; 
  content=new char[length+1]; 
  in.seekg(cur,ios::beg); 
  int i=0; 
  while(!in.eof()){ 
    content[i++]=in.get(); 
  } 
  content[length]=0; 
  in.close(); 
  return content; 
} 
 
void WriteFile(char* path,const char* content,int length,bool append){ 
  ofstream out; 
  if(append){ 
    out.open(path,ios::out|ios::binary|ios::app); 
  } 
  else{ 
    out.open(path,ios::out|ios::binary); 
  } 
   
  out.write(content,length); 
  out.close(); 
} 
 
int main(){ 
  long length; 
  char* content=ReadFile("content.txt",length); 
 
  L_Node* first=0; 
   
  BuildSortedList(content,first,length); //create nodes list and save to nodes file 
  //GetLNodes(first);//get and recreate nodes from file 
 
  Node* root=0;//used for buildtable and decode 
  BuildTree(first,root);//build tree by nodes list and release sorted list 
   
  char* table[256]={//build table,used for encode 
    0 
  }; 
 
  PreOrderTraversal(root,"",-1,table);//create table 
   
 
  char* encode_content=Encode(content,table,length);//convert content to encoded bin text 
  cout<<encode_content<<endl; 
  delete content; 
   
  ReleaseTable(table);//release table when encode finished 
   
   
  int fill_count; 
  int save_length; 
  char* save_text=BinToCharText(encode_content,fill_count,save_length);//convert encoded bin text to char text and save these text to file 
  delete encode_content; 
  char head_info[32]; 
  sprintf(head_info,"%d %d ",fill_count,save_length); 
  WriteFile("encoded_content.txt",head_info,strlen(head_info)); 
  WriteFile("encoded_content.txt",save_text,save_length,true); 
  delete save_text; 
  save_text=ReadFile("encoded_content.txt",fill_count,save_length);//read fill_count、save_length、encoded char text from file 
   
  char* bin_text= CharTextToBin(save_text,fill_count,save_length);//convert char text to bin text 
  delete save_text; 
   
  char* decode_content=Decode(bin_text,root);//decode by bin_text and tree 
  cout<<decode_content<<endl; 
  delete bin_text; 
  delete decode_content; 
   
   
  PostOrderTraversal(root);//release tree 
   
  return 0; 
} 

이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.