二叉树的操作

实验目的：
（1）掌握二叉树的二叉链表存储方式及二叉树的特征；
（2）验证二叉树在二叉链表存储结构下遍历操作的实现；
（3）通过该实验，使学生理解哈夫曼树的概念，掌握哈夫曼树及哈夫曼编码的构造过程，体会网络发送端和接收端编码和译码过程及其工作原理。

实验内容：
2.二叉树的基本操作
1）采用二叉链表结构建立二叉树；
2）编程实现二叉树的先序、中序、后序和层序遍历；
3）编程实现非递归中序遍历
4）编程实现：求二叉树的高度和叶子结点个数；

3.哈夫曼编码
给定报文中26个字母a-z及空格的出现频率{64, 13, 22, 32, 103, 21, 15, 47, 57, 1, 5, 32, 20, 57, 63, 15, 1, 48, 51, 80, 23, 8, 18, 1, 16, 1, 168}，构建哈夫曼树并为这27个字符编制哈夫曼编码，并输出。模拟发送端，从键盘输入字符串，以%为结束标记，在屏幕上输出输入串的编码；模拟接收端，从键盘上输入0-1哈夫曼编码串，翻译出对应的原文。
参考界面

实验代码：

#include<iostream>
#include <bits/stdc++.h>
#define MAX 100//定义数组长度
using namespace std;
typedef struct node{
	char data;
	struct node *lchild;
	struct node *rchild;
}Node, *BTnode;

Node *createBiTree(){
	BTnode root;
	char ch;
	cin >> ch;
	if (ch == '#')
		root = NULL;
	else{
		root = new node;
		root->data = ch;
		root->lchild = createBiTree();
		root->rchild = createBiTree();
	}
	return root;
}
struct Stack
{
	BTnode point[MAX]; 
	
	int top;
};
void Init(Stack &s)
{
	s.top = -1;
}
int Push(Stack &s, BTnode e)
{
	if (s.top>MAX - 1)
		return 0;
	s.top++;
	s.point[s.top] = e;
	return 1;
}
int IsEmpty(Stack s)
{
	if (s.top == -1)
		return 1;
	else
		return 0;
}
Node* Pop(Stack &s){
	if (s.top == -1)
		return NULL;
	BTnode root = s.point[s.top--]; 
	return root;
}

//中序遍历非递归算法
void Inorder(BTnode T){
	Stack s;
	Init(s);
	while (T || !IsEmpty(s)){
		while (T){
			Push(s, T);
			T = T->lchild;
		}
		if (!IsEmpty(s)){
			T = Pop(s);
			cout << T->data << " ";
			T = T->rchild;

		}

	}
}
void inordertraverse(BTnode T)//中序遍历的递归算法
{
	 if(T)
    {
        inordertraverse(T->lchild);
        cout<<T->data<<" ";
        inordertraverse(T->rchild);
    }
}
void beforeordertraverse(BTnode T)//先序 
{
	if(T)
    {
    	cout<<T->data<<" ";
        beforeordertraverse(T->lchild);
        beforeordertraverse(T->rchild);
    }
}
void afterordertraverse(BTnode T)//后序 
{
	if(T)
    {
        afterordertraverse(T->lchild);
        afterordertraverse(T->rchild);
        cout<<T->data<<" ";
    }
}

void level(BTnode p)//层序遍历 
{
    int front,rear;
    BTnode que[MAX];
    front = rear = 0;
    BTnode q;
    if(p!=0)
    {
        rear=(rear+1)%MAX;
        que[rear]=p;
        while(front!=rear)
        {
            front = (front+1)%MAX;
            q=que[front];
            cout << q->data << " ";
            if(q->lchild!=0)
            {
                rear=(rear+1)%MAX;
                que[rear]=q->lchild;
            }
            if(q->rchild!=0)
            {
                rear=(rear+1)%MAX;
                que[rear]=q->rchild;
            }
        }
    }
}


int depth(BTnode t)
{
    if(t==NULL)
    {
        return 0;
    }else
    {
       int m=depth(t->lchild);
       int n=depth(t->rchild);
       if(m>n) return (m+1);
       else return (n+1);
    }
}
int nodecount(BTnode t)
{
    if(t==NULL) return 0;
    else 
	{
	return nodecount(t->lchild)+nodecount(t->rchild)+1;	
	}
}



//哈夫曼编码
int n,s1,s2,m,i,j,count2;
typedef struct HTNode
{
    int weight;
    int parent,lchild,rchild;
}HTNode,*HuffmanTree;
typedef char **HuffmanCode;

void Select(HuffmanTree &HT, int end, int &s1, int &s2)
{
    int min1=66666,min2=66666;
    for(int i=1;i<=end;i++)
    {
        if(HT[i].parent==0&&HT[i].weight<min1)
        {
            min1 = HT[i].weight;
            s1 = i;
        }
    }
    for(int i=1;i<=end;i++)
    {
        if(HT[i].parent==0&&HT[i].weight<min2&&s1!=i)
        {
            min2 = HT[i].weight;
            s2 = i;
        }
    }
}

void CreatHuffmanTree(HuffmanTree &HT, int n)
{
    m = 2*n-1;
    HT = new HTNode[m+1];
    for(i=1;i<=m;i++)
    {
        HT[i].parent=0;
        HT[i].lchild=0;
        HT[i].rchild=0;
    }
    for(i=1;i<=n;i++)
    {
        cin>>HT[i].weight;
    }
    for(i=n+1;i<=m;i++)
    {
        Select(HT,i-1,s1,s2);
        HT[i].weight = HT[s1].weight+HT[s2].weight;
        HT[s1].parent = i;
        HT[s2].parent = i;
        HT[i].lchild = s1;
        HT[i].rchild = s2;
    }

}

void creatHuffmanCode(HuffmanTree HT, HuffmanCode &HC, int n)
{
    int start,c,f;
    HC=new char*[n+1];
    char *cd=new char[n];
    cd[n-1]='\0';
    for(int i=1; i<=n; i++)
    {
        start = n-1;
        c=i;
        f=HT[c].parent;
        while(f!=0)
        {
            start--;
            if(HT[f].lchild==c)
            {
                cd[start]='0';
            }
            else
            {
                cd[start]='1';
            }
            c=f;
            f=HT[f].parent;
        }
        HC[i] = new char[n-start];
        strcpy(HC[i],&cd[start]);
    }
    delete cd;
}



void TransCode(HuffmanTree HT,char a[],char ch[],char b[],int n)
{
    count2=0;
    int q=2*n-1;
    int k=0;
    for(int i=0; a[i]!='%'; i++)
    {
        if(a[i]=='0')
        {
            q=HT[q].lchild;
        }
        else if(a[i]=='1')
        {
            q=HT[q].rchild;
        }
        if(HT[q].lchild==0 && HT[q].rchild==0)
        {
            b[k++]=ch[q-1];
            q=2*n-1;
        }
    }
    count2=k;
    b[k]='\0';
}

void show()
{
    cout<<"*****************************哈夫曼编码*****************************"<<endl;
    cout<<"********* 1.输入HuffmanTree的参数.                        **********"<<endl;
    cout<<"********* 2.初始化HuffmanTree参数(含有26字母及空格).      **********"<<endl;
    cout<<"********* 3.创建HuffmanTree和编码表.                      **********"<<endl;
    cout<<"********* 4.输出编码表.                                   **********"<<endl;
    cout<<"********* 5.输入编码，并翻译为字符.                       **********"<<endl;
    cout<<"********* 6.输入字符，并实现编码.                         **********"<<endl;
    cout<<"********* 7.退出.                                         **********"<<endl;
    cout<<"********* 输入均以%为结束标识                             **********"<<endl;
 
}
 
int main(){
	BTnode root;
	root = NULL;
	cout<<"请输入二叉树节点值："<<endl; 
	root = createBiTree();
	cout<<"中序遍非递归"<<endl; 
	Inorder(root);//中序遍历非递归算法 
	cout<<"\n中序遍历递归"<<endl; 
	inordertraverse(root);
	cout<<"\n先序遍历递归"<<endl; 
	beforeordertraverse(root);
	cout<<"\n后序遍历递归"<<endl; 
	afterordertraverse(root);
	cout<<"\n层序遍历"<<endl; 
	level(root);
	cout<<"\nthe depth of the tree: "<<depth(root)<<endl;
	cout<<"the num of node: "<<nodecount(root)<<endl;
	cout<<endl;
	
	
	
	
	
	
	
	//哈夫曼编码 
	HuffmanTree HT;
    HuffmanCode HC;
    int OpCode;
    int count1=0;
    char a[1000];
    char b[1000];
    char c[1000];
    char ch[27]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',' '};
    show();
    bool flag=true;
    while(flag)
    {
        cout<<"请输入选择:"<<endl;
        cin>>OpCode;
        if(OpCode==1)
        {
            cout<<"请输入编码字符个数: ";
            cin>>n;
        }
        else if(OpCode==2)
        {
            cout<<"请输入权值: ";
            CreatHuffmanTree(HT,n);
        }
        else if(OpCode==3)
        {
            creatHuffmanCode(HT,HC,n);
        }
        else if(OpCode==4)
        {
            cout<<"结点"<<"\t"<<"字符"<<"\t"<<"权值"<<"\t"<<"编码"<<endl;
            for(int i=1;i<=n;i++)
            {
                cout<<i<<"\t"<<ch[i-1]<<"\t"<< HT[i].weight<<"\t"<<HC[i]<<endl;
            }
            cout<<endl;
        }
        else if(OpCode==5)
        {
            cout<<"输入二进制编码: ";
            for(i=0;i<1000;i++)
            {
                cin>>a[i];
                char data = a[i];
                if(a[i]=='%')
                {
                    break;
                }

            }
            TransCode(HT,a,ch,b,n);
            cout<<"输出: ";
            for(i=0;i<count2;i++)
            {
                cout<<b[i];
            }
            cout<<endl;
        }
        else if(OpCode==6)
        {
            count1=0;
            cout<<"请输入一串字符: ";
            for(i=0;i<1000;i++)
            {
                cin>>c[i];
                char data = c[1];
                count1++;
                if(c[i]=='%')
                {
                    break;
                }
            }
            cout<<"输出: ";
            for(i=0;i<count1-1;i++)
            {
                for(j=0;j<n;j++)
                {
                    if(c[i]==ch[j])
                    {
                        cout<<HC[j+1];
                        break;
                    }
                }
            }
            cout<<endl;
        }
        else if(OpCode==7)
        {
            flag=false;
        }
    }
	return 0;
}