求助一道C++霍夫曼编码题

加入译码那段代码之后，不管是在outputfile2.txt中，还是控制台下，都木有任何反应，

但是用F10一步步调试，是木有错误的。。。

为什么为什么？？

哪位大牛，请救救我吧。。。跪谢了

 

 

#include<iostream.h>
#include"fstream.h"
#include<iomanip.h>
#include<string.h>
const int MaxV=1000;            //初始设定的最大权值
const int MaxBit=10;            //初始设定的最大编码位数
const int MaxN=10;              //初始设定的最大结点树

typedef struct     //huffman树的结点结构体
{
 int weight;    //权值
 int flag;      //标记
 int parent;    //双亲结点的下标
 int lchild;    //左孩子下标
 int rchild;    //右孩子下标

}HuffNode;

typedef struct      //huffman结点的编码结构体
{
 char bit[MaxN];  //存放编码的数组
 int start;      //编码的起始下标
 int weight;     //字符的权值
}Code;

class HuffmanT
{
public:
 HuffmanT(HuffNode *&,Code *&,int); //构造函数
 void MakeHufm(int weight[],int n); //创建叶节点个数为n，权值数组为weight的哈弗曼树
 void HuffCode(int n);              //由n个结点的哈弗曼树HuffTree构造哈弗曼编码huffCode
private:
 HuffNode *HuffTree;                //私有成员结点HuffTree
 Code* huffCode;                    //私有成员结点huffCode
};

/函数中三个参数： 结点huffnode，编码huCode，不同字母个数n
HuffmanT::HuffmanT(HuffNode *&huffnode,Code *&huCode,int n) 
{
 huffnode=new HuffNode[2*n+1];
 huCode=new Code[n];
 HuffTree=huffnode;
 huffCode=huCode;
}

/
/  函数中参数含义：weight[]是各字母的权重，即频数，n表示字母个数
void HuffmanT::MakeHufm(int weight[],int n)
{
 int j,m1,m2,x1,x2,i;
 ///哈弗曼树的初始化
 for(i=0;i<2*n-1;i++)
 {
  if(i<n)
   HuffTree[i].weight=weight[i];
  else
   HuffTree[i].weight=0;
  HuffTree[i].parent=0;
  HuffTree[i].flag=0;
  HuffTree[i].lchild=-1;
  HuffTree[i].rchild=-1;
 }
 构造哈弗曼树的n-1个非叶节点
 for(i=0;i<n-1;i++)
 {
  m1=m2=MaxV;
  x1=x2=0;
  for(j=0;j<n+i;j++)
  {
   if(HuffTree[j].weight<m1&&HuffTree[j].flag==0)
   {
    m2=m1;
    x2=x1;
    m1=HuffTree[j].weight;
    x1=j;
   }
   else
    if(HuffTree[j].weight<m2&&HuffTree[j].flag==0)
    {
     m2=HuffTree[j].weight;
     x2=j;
    }
  }
 找出的两棵树权值最小的子树合并为一棵树
  HuffTree[x1].parent=n+i;
  HuffTree[x2].parent=n+i;
  HuffTree[x1].flag=1;
  HuffTree[x2].flag=1;
  HuffTree[n+i].weight=HuffTree[x1].weight+HuffTree[x2].weight;
  HuffTree[n+i].lchild=x1;
  HuffTree[n+i].rchild=x2;

 }
}

///函数中参数含义： n表示字母的个数
void HuffmanT::HuffCode(int n)
{
 Code *cd=new Code;
 int child,parent;
 //求n个叶节点的哈弗曼编码
 for(int i=0;i<n;i++)
 {
  cd->start=n-1;         //不等长编码的最后一位为n-1
  cd->weight=HuffTree[i].weight;//取得编码对应权值的字符
  child=i;
  parent=HuffTree[child].parent;
  ///由叶节点向上直到根结点
  while(parent!=0)
  {
   if(HuffTree[parent].lchild==child)
    cd->bit[cd->start]='0';
   else
    cd->bit[cd->start]='1';
   cd->start--;
   child=parent;
   parent=HuffTree[child].parent;

  }
  保存每个叶节点的编码和不等长编码的起始位
  int m=0;
  for(int j=cd->start+1;j<n;j++)
   huffCode[i].bit[m++]=cd->bit[j];
  huffCode[i].bit[m]='/0';
  huffCode[i].start=cd->start;
  huffCode[i].weight=cd->weight;//记住编码对应权值的字符
 }
}

struct word        //从文件中读入字母结构体
{
 char alph;     //该字母
 int count;     //该字母出现的频数
 bool flag;     //标记（该字母是否已被输出）
 word *next;    //指向下一个结构体
};

void main()
{
 word *nod,*head; 
 nod=new word;
 head=nod;
 int i,j;
 //读取字母并编码之后，将编码放入相应的文件中
 int alph[2][52]={{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};         //alph[0][]---字母，alph[1][]---counter
 char curralph;
 ifstream fin("inputfile1.txt");
 do{
  fin>>curralph;
  if(curralph<='z'&&curralph>='a')
  {
   alph[0][curralph-'a']=1;
   alph[1][curralph-'a']++;
  }
  if(curralph<='Z'&&curralph>='A')
  {
   alph[0][curralph-'A'+26]=1;
   alph[1][curralph-'A'+26]++;
  }
 }while(curralph!='#');
 fin.close();
 int counter=0;                               //共几个字母用counter记录
 for(i=0;i<52;i++)
  if(alph[0][i]==1)
   counter++;
 for(i=0;i<52;i++)                           //将数组中的值输入一个个结点中去，
 {
  if(alph[0][1]==1)
  {
   if(i<26)
   {
    nod->alph='a'+i;
    nod->count=alph[1][i];
    nod->flag=false;
    word *idx;
    nod->next=new word;
    idx=new word;
    idx=nod->next;
    nod=idx;
   }
   else
   {
    nod->alph='A'+i-26;
    nod->count=alph[1][i];
    nod->flag=false;
    word *idx;
    nod->next=new word;
    idx=new word;
    idx=nod->next;
    nod=idx;
   }
  }
 }
 cout<<"Huffman.cpp运行结果：/n";
 int n=counter; 
 HuffNode *myHuffTree;
 myHuffTree=new HuffNode;
 Code *myHuffCode;
 myHuffCode=new Code;
 HuffmanT t(myHuffTree,myHuffCode,n);
 if(n>MaxN)
 {
  cout<<"n 越界，修改MaxN!/n";
//  exit(1);
 }
 t.MakeHufm(alph[1],n);
 t.HuffCode(n);
 //输出每个叶节点的赫夫曼编码
 ofstream fout("outputfile1.txt"); 
 for(i=0;i<n;i++)
 {
  word *curr;
  curr=new word;
  curr=head;
  fout<<"weight="<<myHuffCode[i].weight<<"  Code=";
  int m=0; 
  for(j=myHuffCode[i].start+1;j<n;j++)
  {
   if(myHuffCode[i].bit[m]!='/0')
    fout<<myHuffCode[i].bit[m++];  
  }
  fout<<"   word=";
  
  for(int k=0;k<n;k++)
  {
   if(curr->count==myHuffCode[i].weight&&curr->flag==false)
   {
    fout<<curr->alph;
    curr->flag=true;
    break;
   }
   curr=curr->next;
  }
  fout<<endl;

 }
 fout.close();
// cout<<"ssssssssss";
 读取相应的编码，将对应的字母输入至相应的文档

/加入以下代码（完成译码），控制台什么结果都出不来了？？？这是为什么？
 char currcode;
 ifstream fin1("inputfile2.txt");
 char a[MaxV];
 int m=0;
 do
 {
  fin1>>currcode;
  a[m++]=currcode;
 }while(currcode!='#');
 fin1.close();
 ofstream fout1("outputfile2.txt");
// fout1<<'a';
 for(i=0;i<m;)
 {
  int leng,k;
  bool idx=false;
  char cmp[MaxBit];
  for(j=0;j<n;j++)
  {
      k=0;
   leng=strlen(myHuffCode[j].bit);
   while(k<leng)
   {
    cmp[k]=a[i+k];
    k++;
   }
   cmp[k]='/0';
   if(strcmp(cmp,myHuffCode[j].bit)==0)
   {
    word *curr;
    curr=new word;
    curr=head;
    for(int m=0;m<n;m++)
    {
     if(curr->count==myHuffCode[j].weight)
     {
      cout<<curr->alph;
   //   cout<<"ssssssss";
      fout1<<curr->alph;
   //   fout1<<'0';
      i=i+k;
      idx=true;
      break;
     }
     curr=curr->next;
    }
   }
   if(idx)
    break;
  }
  
 
 }
 fout1.close();

 cin.get();
}