树

　　现在介绍数据结构中的树，由于不像链表、队列、栈一样可以直接的线性化地理解，树在一定程度上给予我们较大的理解问题。由间及难，一般大多开始研究二叉树。

　　先附上最近的数据结构作业——Huffman编码，提供实例参考和理解。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

using namespace std;

typedef struct{
    //char data;
    int weight;
    int lchild,rchild,parent;
}HTNode,*HuffmanTree;

typedef char **HuffmanCode;

void menu(){
    cout<<"-------------------------------------------------------------------------"<<endl;
    cout<<"菜单：输入0-6实现以下操作"<<endl;
    cout<<"0：结束实验！"<<endl;
    cout<<"1：实现对给定源文件的电文字符统计操作！"<<endl;
    cout<<"2：根据统计字符结果建立Huffman树！"<<endl;
    cout<<"3：根据提供正文内容和已经建立好的Huffman树对正文不同字符进行Huffman编码!"<<endl;
    cout<<"4: 实现BuildCodeFiles函数，将正文内容以Huffman编码生成01代码文件!"<<endl;
    cout<<"5: 用Huffman编码对给定译文文件进行译码!"<<endl;
    cout<<"-------------------------------------------------------------------------"<<endl;

}
int Count(char *text,int *w){/**Count返回字符个数，char[]存不同字符，体现种类，w[]存相应的权值**/

    int s=0,i;
    char ch;
    char filename[20];/**？：next[]、w[]动态开数组，对于同一个头地址，后续一个一个添加元素**/
    FILE *fp;
    cout<<"实现电文字符数据统计，输入源文件名："<<endl;
    cin>>filename;
    getchar();

    while((fp=fopen(filename,"r"))==NULL){
        cout<<"无法打开文件！重新输入文件名："<<endl;
        cin>>filename;
        getchar();
    }
    ch=getc(fp);/**问？：fp指针的指向，外层循环先getc，s值正常；若在循环内第一句作为getc开始，ch会在最后在读取一个空字符**/
    while(feof(fp)==0){
        //ch=getc(fp);
        if(s==0){ /**第一个字符**/
            text[s]=ch;
            w[s]++;
            //cout<<text[s]<<w[s]<<endl;
            s++;/**s超前一位；由于树结构不用0号位而text[]w[]都用0号位，相应赋值的数组下标关系需要注意**/
            ch=getc(fp);
            continue;
        }
        for(i=0;i<s;i++){/**每读取成功一个，存入后s++，此处单次循环范围也随之增加*/
            if(ch==text[i]){/**若在已存储的text[]中找到 则对应位置权值数组元素++*/
                w[i]++;
                //cout<<text[i]<<w[i]<<endl;
                break;
            }
        }
        if(i==s){/**未找到，先利用i=S存入，再自加，因为跳出for循环时，i已经++*/
            text[i]=ch;
            w[i]++;
            //cout<<text[i]<<w[i]<<endl;
            s++;
        }
        ch=getc(fp);
    }

    fclose(fp);
    return s;/**?:s-1 **/
}

void Select(HuffmanTree &HT,int i,int &s1,int &s2){/**选择指定范围内的权值最小的两个结点*/
    int j,k;
    int min1;
    int min2;
    for(k=1;k<=i;k++){/**找到每构造一次新的结点时的初态，即最前面的parent=0的结点*/
        if(HT[k].parent==0){
            j=k;
            min1=k;
            min2=k;
            break;
        }
    }
    for(j=k+1;j<=i;j++){/**min1,min2找法不同*/
        if(HT[j].parent==0){
            if(HT[j].weight<HT[min1].weight){/**min1:先定最前无双亲为最小，向后推一个再找比他大的，有则有，无，则为k*/
                //cout<<HT[j].weight<<HT[min1].weight<<"	";
                min1=j;
                //cout<<min1<<endl;
            }
        }
    }
    /**此时min1有两种情况：为k、不为k*/
    for(j=k;j<=i;j++){/**min2:也先定最前无双亲为最小，在定为最小的值即其后找除去min1小于等于最小的；此时包括min1不为k的情况和min1为k且min2在后面找到相应值的情况*/
        if(j==min1){
            continue;
        }
        if(HT[j].parent==0){
            if(HT[j].weight<=HT[min2].weight){
                min2=j;
            }
        }
    }
    if(min2==k&&min1==k){/**此时为min1为k且min2在后面找不到k的情况*/
        for(k=1;k<=i;k++){
            if(HT[k].parent==0&&k!=min1){/**重新找初态，及最前除去min1=k和有双亲的结点*/
                j=k;
                min2=k;
                break;
            }
        }
        for(j=k+1;j<=i;j++){/**同于min1的找法*/
            if(HT[j].parent==0){
                if(HT[j].weight<HT[min2].weight){
                    min2=j;
                }
            }
        }
    }
    s1=min1;
    s2=min2;
    //cout<<s1<<"	"<<s2<<endl;
    return;
}

void BuildHuffmanTree(HuffmanTree &HT,int *w,int n){/**建立Huffman树*/
    if(n<=1){
        cout<<"字符个数不大于1，无法构成Huffman树及相应的Huffman编码！！"<<endl;
        return;
    }
    //cout<<w[0]<<w[1]<<w[2]<<w[3]<<endl;
    int m=2*n-1;
    int i;
    HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));/**0号未用,便于直接理解之后的select的位置范围，外层的text[],w[]运用0号位，对应关系注意**/
    for(i=1;i<=n;i++){ /**1...n的权即是叶子结点输入Huffman树**/
        HT[i].weight=w[i-1];/**w[0]已用，HT[0]未用*/
        HT[i].lchild=HT[i].rchild=HT[i].parent=0;
    }
    for(;i<=m;i++){/**其他结点初赋值为0**/
        HT[i].weight=HT[i].lchild=HT[i].rchild=HT[i].parent=0;
    }
    //cout<<HT[1].weight<<HT[2].weight<<HT[3].weight<<HT[4].weight<<endl;
    int s1=0,s2=0;
    for(i=n+1;i<=m;i++){
        Select(HT,i-1,s1,s2);/**实现挑选，找到最小的两个值，且s1<=s2，注意事项详见Select()**/
        HT[s1].parent=i;
        HT[s2].parent=i;
        HT[i].lchild=s1;
        HT[i].rchild=s2;
        HT[i].weight=HT[s1].weight+HT[s2].weight;
        //cout<<HT[s1].weight<<"+"<<HT[s2].weight<<"="<<HT[i].weight<<endl;
    }
    return;
}

void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int n){/**Huffman编码，生成HC，编码存储于HC*/
    HC=(HuffmanCode)malloc((n+1)*sizeof(char*));/**HC[0]不用，与Huffman树相对应*/
    char *cd=(char *)malloc(n*sizeof(char));/**开n个，即叶子结点数*/
    cd[n-1]='';/**从后向前添加01编码，start记录01编码字符数组的有效首地址，注意个数、长度关系*/
    int start;
    int i,c,f;
    for(i=1;i<=n;i++){
        start=n-1;
        for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent){
            if(HT[f].lchild==c){
                cd[--start]='0';/**先自减，在存入10编码*/
            }
            else{
                cd[--start]='1';
            }
        }
        HC[i]=(char *)malloc((n-start)*sizeof(char));
        strcpy(HC[i],&cd[start]);
    }
    free(cd);
    return;
}

void BuildCodeFiles(HuffmanCode HC,char text[],int n){/**建立正文的编码文件的函数*/
    FILE *fp1,*fp2;
    char filename1[20];
    char filename2[20];
    char ch;
    int find;
    cout<<"输入正文文件名："<<endl;
    cin>>filename1;
    getchar();
    while((fp1=fopen(filename1,"r"))==NULL){
        cout<<"正文文件无法打开，重新输入："<<endl;
        cin>>filename1;
        getchar();
    }
    cout<<"输入正文编码存储的文件名："<<endl;
    cin>>filename2;
    getchar();
    while((fp2=fopen(filename2,"w"))==NULL){
        cout<<"文件打开失败，重新输入文件名："<<endl;
        cin>>filename2;
        getchar();
    }
    ch=getc(fp1);
    while(feof(fp1)==0){
        for(find=0;find<n;find++){
            if(ch==text[find]){
                //cout<<text[find]<<HC[find+1];
                int i=0;
                while(HC[find+1][i]!=''){
                    putc(HC[find+1][i],fp2);
                    i++;
                }
                break;
            }
        }
        ch=getc(fp1);
    }
    fclose(fp1);
    fclose(fp2);
    return;
}

void TranlateCode(HuffmanTree HT,char text[],int n){/**代码文件的译码函数,直接输入？存入译文文件？。根据Huffman树遍历思想找。根据HC找？*/
    FILE *fp;
    char filename[20];
    char ch;
    int find=2*n-1;

    cout<<"输入待破译代码文件名："<<endl;
    cin>>filename;
    getchar();

    while((fp=fopen(filename,"r"))==NULL){
        cout<<"代码文件读取失败，重新输入文件名："<<endl;
        cin>>filename;
        getchar();
    }

    cout<<"译文内容:"<<endl;
    ch=getc(fp);
    while(feof(fp)==0){
        if(HT[find].lchild==0&&HT[find].rchild==0){
            cout<<text[find-1];/**生成译文文件操作：FILE  fp2;putc(text[find-1],fp2);*/
            ch=getc(fp);
            find=2*n-1;/**重新赋值，从Huffman树的最高点遍历*/
            continue;
        }
        if(ch=='0'){
            find=HT[find].lchild;
        }
        else if(ch=='1'){
            find=HT[find].rchild;
        }
        else{
            cout<<"代码文件内容有误，无法破译。"<<endl;
            exit(0);
        }

        if(HT[find].lchild==0&&HT[find].rchild==0){/**这段不能少！若少，上部分代码find下指，若这里不判断，直接读取ch，循环继续，再判断，若恰为叶子结点，再读取ch，数据替代*/
            cout<<text[find-1];
            ch=getc(fp);
            find=2*n-1;
            continue;
        }
        ch=getc(fp);
    }
    cout<<endl;
    fclose(fp);
    return;
}

int main()
{
    int i=0,n;
    char text[100]={0};
    int w[100]={0};
    char goal;
    HuffmanTree HT;
    HuffmanCode HC;
    menu();
    cin>>goal;
    getchar();
    while(goal!='0'){
        switch(goal){
            case '1': for(i=0;i<100;i++){
                        text[i]=0;
                        w[i]=0;
                    }
                    n=Count(text,w);
                    cout<<"该电文有"<<n<<"种字符，字符和对应的权值如下："<<endl;
                    cout<<"字符"<<"	"<<"权值"<<endl;
                    for(i=0;i<n;i++){
                        cout<<" "<<text[i]<<"	"<<" "<<w[i]<<endl;
                    }
                    cout<<"回车继续..."<<endl;
                    getchar();
                    menu();
                    cin>>goal;
                    getchar();
                    break;
            case '2': free(HT);
                    cout<<"建立Huffman树："<<endl;
                    BuildHuffmanTree(HT,w,n);
                    cout<<"Huffman编码树："<<endl;
                    for(i=1;i<=2*n-1;i++){
                        cout<<HT[i].weight<<" ";
                    }
                    cout<<endl;
                    cout<<"回车继续..."<<endl;
                    getchar();
                    menu();
                    cin>>goal;
                    getchar();
                    break;
            case '3': cout<<"实现Huffmancode编码函数"<<endl;
                    free(HC);
                    HuffmanCoding(HT,HC,n);
                    cout<<"字符与对应的Huffman编码如下："<<endl;
                    for(i=1;i<=n;i++){
                        cout<<text[i-1]<<":"<<HC[i]<<endl;
                    }
                    cout<<"回车继续..."<<endl;
                    getchar();
                    menu();
                    cin>>goal;
                    getchar();
                    break;
            case '4': BuildCodeFiles(HC,text,n);
                    cout<<"回车继续..."<<endl;
                    getchar();
                    menu();
                    cin>>goal;
                    getchar();
                    break;
            case '5': cout<<"实现TranlateCode函数"<<endl;
                    TranlateCode(HT,text,n);
                    cout<<"回车继续..."<<endl;
                    getchar();
                    menu();
                    cin>>goal;
                    getchar();
                    break;
            case '0': break;
            default:cout<<"不合法输入，没有该操作！请重新输入："<<endl;
                    cin>>goal;
                    getchar();
                    break;
        }
    }
    return 0;
}

　　同样也有顺序和链式的分类，区别在于父子关系的传递：顺序结构是利用静态数组本身的线性关系，用数组下标表示双亲和左右孩子的关系；链式结构是利用结构体中定义出特定的指针域来指向双亲或是左右孩子。一般没有什么特殊要求和目的，顺序结构常用一些。