头歌编程题实训-树

scombUst1ble

于 2024-11-30 19:40:10 发布

阅读量730

点赞数 23

分类专栏：头歌实训文章标签：算法 c++ 数据结构

本文链接：https://blog.youkuaiyun.com/fireable_ice810/article/details/144159432

版权

头歌实训专栏收录该内容

3 篇文章

订阅专栏

如果是赶ddl建议之后补票，树挺重要的

第1关：基于哈夫曼树的数据压缩算法

#include<iostream>
#include<string.h>
#define MAXSIZE 100
using namespace std;
typedef struct
{//哈夫曼树结点的形式
	int weight;               //结点的权值
	int parent,lchild,rchild;  //结点的双亲、左孩子、右孩子的下标
}HTNode,*HuffmanTree;       //动态分配数组存储哈夫曼树
typedef char **HuffmanCode;   //定义编码表类型
int Search(char a[],char ch)
{//查找数组中字符ch所在的位置，返回数组下标，否则返回-1
	for(int i=0;a[i]!='\0';i++)
	{
		if(a[i]==ch) return i;
	}
	return -1;
}
void Sort(char a[],int b[],int len)
{//按ASCII码冒泡排序
/**************begin************/
for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - i - 1; j++) {
            if (strcmp(&a[j], &a[j + 1]) > 0) { // 如果前面的字符比后面的字符大
                char temp = a[j];
                int t = b[j];
                a[j] = a[j + 1];
                a[j + 1] = temp; //把前面的字符和后面的字符交换
                b[j] = b[j+1];
                b[j+1] = temp;//b同上
            }
        }
    }
    /**************end************/
}
void Select_min(HuffmanTree HT,int n,int &s1,int &s2)
{// 在HT[k](1≤k≤i-1）中选择两个其双亲域为0且权值最小的结点，并返回它们在HT中的序号s1和s2
/**************begin************/
int MIN1=0x3f3f3f3f,MIN2=0x3f3f3f3f;//MIN1最小值，MIN2次小值  0x3f3f3f3f表示为数值初始化成正无穷大
    for(int i=1;i<=n;i++){
        if(!HT[i].parent&&HT[i].weight<MIN1){
            //小于最小值 把最小值赋值给次小值 并把最小值的下标赋值给次小值的下标
            MIN2=MIN1;
            s2=s1;
            MIN1=HT[i].weight;
            s1=i;
        }
        else if(!HT[i].parent&&HT[i].weight<MIN2){
            //小于次小值
            MIN2=HT[i].weight;
            s2=i;
        }
    }
    /**************end************/
}
int m;
void CreateHuffmanTree(HuffmanTree &HT,int n,int b[])
{//构造哈夫曼树HT
/**************begin************/
	if(n<=1) return;
    m = 2*n-1; //n个权值共有2n-1个节点
    HT = new HTNode[m+1];//从下标为1开始，所以分配m+1个单元
    for(int i=1;i<=m;i++)
    {
        //初始化为0 防止存储之前的旧数据
        HT[i].parent = 0;
        HT[i].lchild = 0;
        HT[i].rchild = 0;
    }
    for(int i=0;i<n;i++)
    {
        HT[i+1].weight = b[i];
    }
    int s1,s2;
    for(int i=n+1 ; i<=m; i++)
    {
        Select_min(HT,i-1,s1,s2);
        HT[s1].parent = i;HT[s2].parent = i;//双亲由0改为i
        HT[i].lchild = s1;
        HT[i].rchild = s2; //s1和s2分别作为i的左右孩子
        HT[i].weight = HT[s1].weight + HT[s2].weight;//i的权值为左右孩子权值之和
    }
    /**************end************/
}
void CreateHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n)
{//从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
/**************begin************/
//课本136页
	HC = new char*[n+1];//分配存储n个字符编码的编码表空间
    char *cd = new char[n];//分配临时存放每个字符编码的动态数组空间
    cd[n-1]='\0';//编码结束符
    for (int i=1;i<=n;i++)
    {
        int start=n-1;//start开始时指向最后，即编码结束符位置
        int c=i;
        int f=HT[i].parent;//f指向节点c的双亲结点
        while(f!=0)
        {
            start--;
            if(HT[f].lchild == c) cd[start]='0';//结点c是f的左孩子，则生成代码0
            else cd[start] ='1';//结点c是f的右孩子，则生成代码1
            c = f;
            f = HT[f].parent;//继续向上回溯
        }
        HC[i]=new char[n-start];//为第i个字符的编码分配空间
        strcpy(HC[i],&cd[start]);//将求得的编码从临时空间cd复制到HC的当前行中

    }
    delete cd;//释放临时空间
    /**************end************/
}
void CharFrequency(char ch[],char a[],int b[],int &j)
{//统计词频
/**************begin************/
a[0] = ch[0];//先存储第一个
j = 1;//j初始化为1
for(int i=0;i<strlen(ch);i++)
{
    int index = Search(a,ch[i]);
    if(index > -1)
    {  //在其中
        b[index]++;
    }else
    {  //不在其中
        b[strlen(a)] = 1;
        a[strlen(a)] = ch[i];
        j++;
    }
}
    /**************end************/
}
void PrintHT(HuffmanTree HT)
{//输出哈夫曼树的存储结构的终态
/**************begin************/
//m在56行已经定义
for (int i=1;i<=m;i++)
{
    cout << i << " " << HT[i].weight << " " << HT[i].parent << " " << HT[i].lchild << " " << HT[i].rchild << endl;
}
    /**************end************/
}
void PrintHC(HuffmanCode HC,char a[],int j)
{//输出每个字符的哈夫曼编码
/**************begin************/
for(int i=1 ; i<=j; i++){
    if(i == j)
    {
        cout<<a[i-1]<<":"<<HC[i]<<endl;//最后一个直接换行
    }else{
        cout<<a[i-1]<<":"<<HC[i]<<" ";
    }
}
    /**************end************/
}
int main()
{
	char ch[MAXSIZE];
	int i,j;
	while(cin>>ch)
	{
		if(ch[0]=='0') break;
		HuffmanTree HT;
		char a[MAXSIZE]={'\0'};
		int b[MAXSIZE]={0};
		j=0;      //j统计不同字符的数量
		CharFrequency(ch,a,b,j);   //统计词频
		Sort(a,b,j);     //按ASCII码冒泡排序
		for(i=0;a[i]!='\0';i++)   //输出统计出来的字符和出现频率
		{
			if(a[i+1]!='\0')
				cout<<a[i]<<":"<<b[i]<<" ";
			else
				cout<<a[i]<<":"<<b[i]<<endl;
		}
		//构造哈夫曼树
		CreateHuffmanTree(HT,i,b);    //构造哈夫曼树HT
		PrintHT(HT);      //输出哈夫曼树的存储结构的终态
		//哈夫曼编码
		HuffmanCode HC;    //编码表HC
		CreateHuffmanCode(HT,HC,j);
		PrintHC(HC,a,j);    //输出每个字符的哈夫曼编码
		int k;
		for(i=0;ch[i]!='\0';i++)    //输出编码后的字符串
		{
			for(k=0;k<j;k++)
			{
				if(ch[i]==a[k])
					cout<<HC[k+1];
			}
		}
		cout<<endl;
		cout<<ch<<endl;//输出解码后的字符串（与输入的字符串相同）
	}
	return 0;
}

第2关：基于二叉链表的树结构相等的判断

#include<iostream>
using namespace std;
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T,char S[],int &i)
{先序建立二叉树
/**************begin************/
    if (S[i] == '0')
    {
        T = NULL;
    }
    else
    {
        T = new BiTNode;
        T->data = S[i];
        CreateBiTree(T->lchild, S, ++i);
        CreateBiTree(T->rchild, S, ++i);
    }

    /**************end************/
}
int Compare(BiTree T1,BiTree T2)
{//判断两棵二叉树是否相等，不相等返回0，相等返回1
/**************begin************/
    if (T1 == NULL && T2 == NULL) // 两棵树都为空，认为相等
        return 1;
 
    if (T1 == NULL || T2 == NULL) // 两棵树中仅有一棵为空，认为不相等
        return 0;
 
    if (T1->data != T2->data) // 节点值不相等，认为不相等
        return 0;
 
    int leftEqual = Compare(T1->lchild, T2->lchild); // 比较左子树
    int rightEqual = Compare(T1->rchild, T2->rchild); // 比较右子树
 
    return leftEqual && rightEqual; // 左右子树都相等才认为相等

    /**************end************/
}
int main()
{
	char S1[100],S2[100];
	while(cin>>S1&&S1[0]!='0')
	{
		cin>>S2;
		int i=-1,j=-1;
	  	BiTree T1,T2;
		CreateBiTree(T1,S1,++i);
		CreateBiTree(T2,S2,++j);
		if(!Compare(T1,T2))
			cout<<"NO"<<endl;
		else
			cout<<"YES"<<endl;
	}
	return 0;
}

第3关：基于二叉链表的二叉树左右孩子的交换

#include<iostream>
#include<cstring>
using namespace std;
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T,char S[],int &i)
{//先序建立二叉树
	if(S[i]=='0')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=S[i];
		CreateBiTree(T->lchild,S,++i);
		CreateBiTree(T->rchild,S,++i);
	}
}
void ChangeRL(BiTree &T)
{//二叉树左右孩子的交换
/**************begin************/
	if (T)
	{
		BiTree tmp = T->lchild;
		T->lchild = T->rchild;
		T->rchild = tmp;
		ChangeRL(T->lchild), ChangeRL(T->rchild);
	}
	else
		return;
    /**************end************/
}
void PreOrderTraverse(BiTree T)
{//先序遍历
	if(T)
	{
    	cout<<T->data;
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}
int main()
{
	char S[100];
	while(cin>>S)
    {
        if(strcmp(S,"0")==0) break;
		int i=-1;
	  	BiTree T;
		CreateBiTree(T,S,++i);
		ChangeRL(T);
		PreOrderTraverse(T);
		cout<<endl;
	}
	return 0;
}

第4关：基于二叉链表的二叉树的双序遍历

#include<iostream>
#include <string.h>
using namespace std;
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T,char S[],int &i)
{//先序建立二叉树
	if(S[i]=='0')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=S[i];
		CreateBiTree(T->lchild,S,++i);
		CreateBiTree(T->rchild,S,++i);
	}
}
void DoubleTraverse(BiTree T)
{//双序遍历二叉树T的递归算法
/**************begin************/
	if(T){
		cout<<T->data;
		DoubleTraverse(T->lchild);
		cout<<T->data;
		DoubleTraverse(T->rchild);
	}
    /**************end************/
}
int main()
{
	char S[100];
	while(cin>>S)
    {
        if(strcmp(S,"0")==0) break;
        int i=-1;
	  	BiTree T;
		CreateBiTree(T,S,++i);
		DoubleTraverse(T);
		cout<<endl;
	}
	return 0;
}

第5关：基于二叉链表的二叉树最大宽度的计算

#include <iostream>
#include <string.h>
using namespace std;

typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

BiTree CreateBiTree(int &pos, char *str)
{// 先序建立二叉树
    char c=str[pos++];
    if(c=='0') return NULL;
    BiTree root=new BiTNode();
    root->data=c;
    root->lchild=CreateBiTree(pos,str);
    root->rchild=CreateBiTree(pos,str);
    return root;
}

int Width(BiTree T)
{// 求二叉树T最大宽度
/**************begin************/
	if(T==NULL)
		return 0;
 	BiTree Q[100];
  	int front=1,rear=1,last=1,width=0,WidthMax=0;
	Q[rear]=T;	
	while(front<=last)
	{
      	width++;
		BiTree P=Q[front++];
		if(P->lchild)		
			Q[++rear]=P->lchild;
		if(P->rchild)
			Q[++rear]=P->rchild;
		if(front>last)
		{
			last=rear;
			WidthMax=WidthMax>width?WidthMax:width;
			width=0;
		}
	}
  	return WidthMax;

    /**************end************/
}

int main()
{
    char str[1000];
    while(cin>>str)
    {
        if(strcmp(str,"0")==0) break;
        int pos=0;                         // 标记字符串处理位置
        BiTree root=CreateBiTree(pos,str);
        cout<<Width(root)<<endl;
    }
    return 0;
}

第6关：基于二叉链表的二叉树最长路径的求解

#include<iostream>
#define MAXSIZE 100
using namespace std;
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T,char S[],int &i)
{//程序生成器
	if(S[i]=='0')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=S[i];
		CreateBiTree(T->lchild,S,++i);
		CreateBiTree(T->rchild,S,++i);
	}
}
void LongestPath(BiTree T)
{//双击以监控参考的最大数量B
/**************begin************/
    BiTree p=T,l[MAXSIZE],s[MAXSIZE];
    //1.秒是堆栈中两个点的指示器，当前库存中的结果保持在1级中间
    int top=0,tag[MAXSIZE],longest=0;
    //Tag是标记标记的数量，元素是？第一排当前站点的试用费已经支付，第二排已经收取了很长时间
    while(p||top>0)
    {
        while(p)//当p大于0
        {
            s[++top]=p;
            tag[top]=0;
            p=p->lchild;
        }
        if(tag[top]==1)//测试值是否已降低
        {
            if(!s[top]->lchild&&!s[top]->rchild)//只有当存在数据块时，前视图路径的长度才会更长
            {
                if(top>longest) //最大长度
                {
                    for(int j=1;j<=top;j++) l[j]=s[j];//将当前的最高值保留
                    longest=top;
                }
            }
            top--;
         }
        else if(top>0)
        {
            tag[top]=1;
            p=s[top]->rchild;
        }
    }
    cout<<longest<<endl;
    for(int k=1;k<=longest;k++)
        cout<<l[k]->data;
    cout<<endl;
    /**************end************/
}
int main()
{
	char S[100];
	while(cin>>S&&S[0]!='0')
	{
		int i=-1;
		BiTree T;
		CreateBiTree(T,S,++i);
		LongestPath(T);
	}
	return 0;
}

第7关：基于二叉链表的二叉树叶子结点到根结点的路径的求解

#include<iostream>
using namespace std;
char path[100];  //路径数组，存储路径上每个结点的值
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T,char S[],int &i)
{//先序建立二叉树
	if(S[i]=='0')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=S[i];
		CreateBiTree(T->lchild,S,++i);
		CreateBiTree(T->rchild,S,++i);
	}
}
void AllPath(BiTree T,char path[],int pathlen)
{//二叉树叶子结点到根结点的路径的求解
/**************begin************/
    int i;
	if(T!=NULL){	
		if(T->lchild==NULL && T->rchild==NULL){
			cout<<T->data;
			for(i=pathlen-1;i>=0;i--)
				cout<<path[i];
			cout<<endl;
		}
		else{
			path[pathlen]=T->data;
			pathlen++;
			AllPath(T->lchild,path,pathlen);
			AllPath(T->rchild,path,pathlen);
			pathlen--;
		}
	}
    /**************end************/
}
int main()
{
	char S[100];
	while(cin>>S&&S[0]!='0')
	{
		int i=-1;
		BiTree T;
		CreateBiTree(T,S,++i);
		int pathlen=0;         //初始化路径到根结点的长度为0
        AllPath(T,path,pathlen);
	}
	return 0;
}

第8关：基于二叉链表的二叉树的遍历

#include<iostream>
#include<string.h>
using namespace std;
int flag;
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T,char S[],int &i)
{//先序建立二叉树
	if(S[i]=='0')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=S[i];
		CreateBiTree(T->lchild,S,++i);
		CreateBiTree(T->rchild,S,++i);
	}
}
void PreOrderTraverse(BiTree T)
{//二叉树的先序遍历
/**************begin************/
    if(T){
        cout<<T->data;
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
    /**************end************/
}
void InOrderTraverse(BiTree T)
{//二叉树的中序遍历
/**************begin************/ 
    if(T){
        InOrderTraverse(T->lchild);
        cout<<T->data;
        InOrderTraverse(T->rchild);
    }
    /**************end************/
}
void PostOrderTraverse(BiTree T)
{//二叉树的后序遍历
/**************begin************/
    if(T){
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        cout<<T->data;
    }
    /**************end************/
}
int main()
{
	char S[100];
	while(cin>>S)
	{
		if(strcmp(S,"0")==0) break;
		int i=-1;
	  	BiTree T;
		CreateBiTree(T,S,++i);
		PreOrderTraverse(T);
		cout<<endl;
  	    InOrderTraverse(T);
		cout<<endl;
		PostOrderTraverse(T);
		cout<<endl;
	}
	return 0;
}

第9关：基于二叉链表的二叉树结点个数的统计

#include<iostream>
#include<string.h>
using namespace std;
int a,b,c;//a、b、c分别表示度为0、1、2的结点个数
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T,char S[],int &i)
{//先序建立二叉树
	if(S[i]=='0')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=S[i];
		CreateBiTree(T->lchild,S,++i);
		CreateBiTree(T->rchild,S,++i);
	}
}
void Count(BiTree T)
{//二叉树结点个数的统计
/**************begin************/
    if(T!=NULL){
        if(T->lchild&&T->rchild)  //度为2的结点
            c++;
        else if(T->lchild||T->rchild)   //度为1的结点
            b++;
        else         //度为0的结点
            a++;
        Count(T->lchild);
        Count(T->rchild);
    }
    /**************end************/
}
int main()
{
	char S[100];
	while(cin>>S)
	{
	    if(strcmp(S,"0")==0) break;
		a=b=c=0;
      	int i=-1;
	  	BiTree T;
		CreateBiTree(T,S,++i);
		Count(T);
		cout<<a<<" "<<b<<" "<<c<<endl;
	}
	return 0;
}

第10关：基于二叉链表的二叉树高度的计算

#include<iostream>
#include <string.h>
using namespace std;
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T,char S[],int &i)
{//先序建立二叉树
	if(S[i]=='0')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=S[i];
		CreateBiTree(T->lchild,S,++i);
		CreateBiTree(T->rchild,S,++i);
	}
}
int Depth(BiTree T)
{//二叉树高度的计算
/**************begin************/
	int m,n;
	if(!T) return 0;
	else{
		m=Depth(T->lchild);
		n=Depth(T->rchild);
		if(m>n) return (m+1);
		else return (n+1);
	}	 
    /**************end************/
}
int main()
{
	char S[100];
	while(cin>>S)
	{
	    if(strcmp(S,"0")==0) break;
		int i=-1;
	  	BiTree T;
		CreateBiTree(T,S,++i);
		cout<<Depth(T)<<endl;
	}
	return 0;
}

第11关：基于二叉树的表达式求值

#include<iostream>
#define MAXSIZE 100
using namespace std;
typedef struct BiTNode
{//二叉树的双链表存储表示
	double data;          //结点数据域
	bool ischaracter;      //判断结点是否为字符
	struct BiTNode *lchild,*rchild;    //左右孩子指针
}BiTNode,*BiTree;
typedef struct
{//字符栈的存储结构
	char *base;     //栈底指针
	char *top;       //栈顶指针
	int stacksize;   //栈可用的最大容量
}SqStack1;
typedef struct
{//结点栈的存储结构
	BiTree *base;
	BiTree *top;
	int stacksize;
}SqStack2;
void InitStack1(SqStack1 &s)
{//字符栈的初始化
	s.base=new char[MAXSIZE];  //为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
	s.top=s.base;              //初始为空栈
	s.stacksize=MAXSIZE;        //置栈的最大容量为MAXSIZE
}
void InitStack2(SqStack2 &s)
{//结点栈的初始化
	s.base=new BiTree[MAXSIZE];
	s.top=s.base;
	s.stacksize=MAXSIZE;
}
void Push1(SqStack1 &s,char ch)
{//字符入栈操作
	if(s.top-s.base==s.stacksize)   //栈满
		return;
	*s.top=ch;    //元素ch压入栈顶
	s.top++;       //栈顶指针加1
}
void Push2(SqStack2 &s,BiTree t)
{//结点入栈操作
	if(s.top-s.base==s.stacksize)
		return;
	*s.top=t;
	s.top++;
}
void Pop1(SqStack1 &s,char &ch)
{//字符出栈操作
	if(s.top==s.base)     //栈空
		return;
	else
	{
		s.top--;     //栈顶指针减1
		ch=*s.top;   //将栈顶元素赋给ch
	}
}
void Pop2(SqStack2 &s,BiTree &t)
{//结点出栈操作
	if(s.top==s.base)
		return;
	else
	{
		s.top--;
		t=*s.top;
	}
}
char GetTop(SqStack1 s)
{//取字符栈的栈顶元素
	if(s.base==s.top)    //栈空
		return -1;
	else
		return *(s.top-1);    //返回栈顶元素的值，栈顶指针不变
}
bool EmptyStack(SqStack1 s)
{//栈的判空操作
	if(s.base==s.top)   //栈空返回true
		return true;
	else
		return false;   //栈非空返回false
}
char Precede(char a,char b)
{//判断符号的优先级
	if(a=='+'||a=='-')
	{
		if(b=='+'||b=='-'||b==')'||b=='=')
			return '>';    //>代表a的优先级高于b
		else
			return '<';
	}
	else if(a=='*'||a=='/')
	{
		if(b=='+'||b=='-'||b=='*'||b=='/'||b==')'||b=='=')
			return '>';
		else
			return '<';
	}
	else if(a=='(')
	{
		if(b==')')
			return '=';
		else
			return '<';
	}
	else if(a==')')
			return '>';
	else
	{
		if(b=='=')
			return '=';
		else
			return '<';
	}
}
double Operate(double a,char ch,double b)
{//运算操作，返回相应的数值结果
	if(ch=='+')
		return a+b;
	else if(ch=='-')
		return a-b;
	else if(ch=='*')
		return a*b;
	else
		return a/b;
}
bool IsCharacter(char ch)
{//判断ch是否为+、-、*、/、(、)、= 这类的字符，是则返回true
	if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')'||ch=='=')
		return true;
	else
		return false;
}
double InOrder(BiTree T)
{//中序遍历二叉树并求表达式的值
/**************begin************/
    double m,n;
    char opr;
    if(T!=NULL)
    {
        if(T->ischaracter==false)
            return T->data;  
        else
        {
            m=InOrder(T->lchild);   //递归遍历左子树
            opr=(char)(T->data);     
            n=InOrder(T->rchild);   //递归遍历右子树
            return Operate(m,opr,n);   
        }
    }
    else
        return 0;
        /**************end************/
}
void CreateBT(char ch[],BiTree &t,SqStack1 optr,SqStack2 expt)
{//创建二叉树

    int i=0;
    char opr,c[2];  //辅助数组c
    BiTree t1,t2;
    double num;
    while(ch[i]!='\0'||!EmptyStack(optr))
    {
        if(!IsCharacter(ch[i]))     //当前遍历的不是运算符元素
        {
            c[0]=ch[i];
            c[1]='\0';
            BiTree q=new BiTNode;     //生成一个新结点*q
            num=strtod(c,NULL);      //将字符数组c转换成浮点数，赋给num
            q->ischaracter=false;   //结点*q不为运算符
            q->data=num;            //结点数据域置为num
            q->lchild=NULL;         //左右孩子置为NULL
            q->rchild=NULL;
            Push2(expt,q);       //将结点q压入数字栈
            i++;                  //指针i加1
        }//if
        else                 //当前遍历的是运算符元素
        {
            switch(Precede(GetTop(optr),ch[i]))    //比较栈顶元素和当前遍历字符的优先级
            {
                case '<':                //栈顶元素优先级小于当前运算符
                    Push1(optr,ch[i]);     //将当前运算符入栈
                    i++;                  //指针i加1
                    break;
                case '>':              //栈顶元素优先级大于当前运算符
                    Pop1(optr,opr);     //运算符栈的元素出栈
                    Pop2(expt,t2);      //数字栈的栈顶元素出栈
                    Pop2(expt,t1);
                    t=new BiTNode;      //生成新结点*t
                    t->ischaracter=true;     //结点*t为运算符
                    t->data=opr;          //结点数据域置为opr
                    t->lchild=t1;        //左孩子指向t1
                    t->rchild=t2;        //右孩子指向t2
                    Push2(expt,t);       //将结点t压入数字栈
                    break;
                case '=':         //栈顶元素优先级等于当前运算符
                    Pop1(optr,opr);    //运算符栈的元素出栈
                    i++;                //指针i加1
                    break;
            }//switch
        }//else
    }//while
}
int main()
{
	char ch[MAXSIZE];
	while(cin>>ch)
	{
		if(ch[0]=='=') break;
		BiTree t;
		SqStack1 optr;      //运算符栈optr
		SqStack2 expt;        //数字栈expt
		InitStack1(optr);     //初始化栈
		InitStack2(expt);     //初始化栈
		Push1(optr,'=');    //先在运算符栈底放入一个'='
		CreateBT(ch,t,optr,expt);       //创建二叉树
		double answer=InOrder(t);
		cout<<answer<<endl;
	}
	return 0;
}

第12关：二叉树的WPL计算

#include<iostream>
using namespace std;
typedef struct BiTNode
{
	int weight;
	struct BiTNode *left,*right;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T)
{//先序建立二叉树
	int x;
	cin>>x;
	if(x==0) T=NULL;
	else
    {
		T=new BiTNode;
		T->weight=x;
		CreateBiTree(T->left);
		CreateBiTree(T->right);
	}
}
int WPL(BiTree &T,int d)
{//求二叉树T的带权路径长度
/**************begin************/
    int wpl = 0;
	if (T != NULL){
		if (T->left == NULL && T->right == NULL)
			wpl += d * T->weight;
		wpl += WPL(T->left, d + 1);
		wpl += WPL(T->right, d + 1);
	}
	return wpl;
    /**************end************/
}
int main()
{
	while(1)
    {
		BiTree T;
		CreateBiTree(T);
		if(!T) break;
		int d=0;          //调用时T指向二叉树的根结点，d为0
		cout<<WPL(T,d)<<endl;
	}
	return 0;
}