树和二叉树——数据结构实验报告
实习报告
题目：编写一个实现基于二叉树表示的算术表达式Expression操作程序
班级：姓名：学号：完成日期//
一、需求分析
算术表达式Expression内可以含有变量（a～z）、常量（0～9）和二元算术符（+,-,*,/,∧（乘幂））。实现以下操作：
（1）ReadExpr(E)――以字符序列的形式输入语法正确的前缀表达式并构造表达式E。
（2）WriteExpr(E)――用带括号的中缀表达式输出表达式E。
（3）Assign(V，c)――实现对变量V的赋值（V=c），变量的初值为0。
（4）Value(E)――对算术表达式E求值。
（5）CompoundExpr(p,E1,E2)――构造一个新的复合表达式（E1）p（E2）。
二、概要设计
1、数据类型的声明：
在这个课程设计中，采用了链表二叉树的存储结构，以及两个顺序栈的辅助存储结构
/*头文件以及存储结构*/
#include
#include
#include
#include
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW 0
typedef int Status;
2、表达式的抽象数据类型定义
ADT Expression{
数据对象D：D是具有数值的常量C和没有数值的变量V；
数据关系：R={<(V或者C)P(V或者C)>|V,C∈D, <(V或者C)P(V或者C)>表示由运算符P结合起来的表达式E}
基本操作：
Status Input_Expr(&string,flag)
操作结果：以字符序列的形式输入语法正确的前缀表达式，保存到字符
串string；参数flag表示输出的提示信息是什么，输入成功返回OK，
否则，返回ERROR。
void judge_value(&E,&string,i)
初始条件：树E存在，表达式的前缀字符串string存在；
操作结果：判断字符string[i]，如果是'0'-'9'常量之间，二叉树结
点E存为整型；否则，存为字符型。
Status ReadExpr(&E,&exprstring)
初始条件：表达式的前缀形式字符串exprstring存在；
操作结果：以正确的前缀表示式exprstring并构造表达式E，构造成
功，返回OK，否则返回ERROR。
Status Pri_Compare(c1,c2)
初始条件：c1和c2是字符；
操作结果：如果两个字符是运算符，比较两个运算符的优先级，c1比
c2优先，返回OK，否则返回ERROR。
void WriteExpr(&E)
初始条件：表达式E存在；
操作条件：用带括弧的中缀表达式输入表达式E。
void Assign(&E,V,c,&flag)
初始条件：表达式E存在，flag为标志是否有赋值过；
操作结果：实现对表达式E中的所有变量V的赋值(V=c)。
long Operate(opr1,opr,opr2)
初始条件：操作数opr1和操作数opr2以及操作运算符opr;
操作结果：运算符运算求值，参数opr1,opr2为常量，opr为运算符，
根据不同的运算符，实现不同的运算，返回运算结果。
Status Check(E)
初始条件：表达式E存在；
操作结果：检查表达式E是否还存在没有赋值的变量，以便求算数表达
式E的值。
long Value(E)
初始条件：表达式E存在；
操作结果：对算术表达式求值，返回求到的结果。
void CompoundExpr(P,&E1,E2)
初始条件：表达式E1和E2存在；
操作条件：构造一个新的复合表达式(E1)P(E2)。
Status Read_Inorder_Expr(&string,&pre_expr)
操作结果：以表达式的原书写形式输入，表达式的原书写形式字符串
string变为字符串pre_expr，后调用reversal_string()函数反转得
到前缀表达式pre_expr。得到正确的前缀表达式返回OK，否则，返回
ERROR。
void MergeConst(&E)
操作结果：常数合并操作，合并表达式E中所有常数运算。
}ADT Expression
3、整体设计
1、顺序栈的基本操作：
对于栈SqStack:
Status InitStack(SqStack *S) /* 构造一个空栈S */
Status StackEmpty(SqStack S) /* 若栈S为空栈，则返回TRUE，否则返回FALSE */
Status Push(SqStack *S,SElemType e) /* 插入元素e为新的栈顶元素 */
Status Pop(SqStack *S,SElemType *e) /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status GetTop(SqStack S,SElemType *e) /* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
对于栈SqStack1:
Status InitStack1(SqStack1 *S) /* 构造一个空栈S */
Status StackEmpty1(SqStack1 S) /* 若栈S为空栈，则返回TRUE，否则返回FALSE */ Status Push1(SqStack1 *S,SElemType1 e) /* 插入元素e为新的栈顶元素 */
Status Pop1(SqStack1 *S,SElemType1 *e) /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status GetTop1(SqStack1 S,SElemType1 *e) /* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
2、主程序模块的整体流程
在主函数中，采用多分支程序设计语句switch()使程序产生不同的流向，从而达到实现课程设计的各个要求。
void main()
{
printf("\n 1 >>>输入正确的前缀表达式");
printf("\n 2 >>>带括弧的中缀表示式输出");
printf("\n 3 >>>对变量进行赋值");
printf("\n 4 >>>对算数表达式求值");
printf("\n 5 >>>构造一个新的复合表达式");
printf("\n 0 >>>退出");
while(1)
{
switch( )
{
根据不同的选择，调用不同的操作函数，完成各个操作；
}
}
}
2、本程序有四个模块，主程序模块，二叉树模块，两个顺序栈模块。四者的调用关系如下：
主程序模块中的对于表达式的存储结构调用了二叉树模块，而在构造表达式的二叉树模块中又调用了顺序栈SqStack模块，主程序中在将原表达式形式输入表达式转换为前缀表达式操作中调用了顺序栈SqStack1模块。
三、 详细设计
1、二叉树的存储类型
/*二叉树结点类型*/
typedef enum{INT,CHAR}ElemTag;/*INT 为整型数据num ，CHAR 为字符型数据c*/ typedef struct TElemType
{
ElemTag tag;/*{INT,CHAR}指示是整型还是字符型*/
union
{
int num;/*tag=INT 时，为整型*/
char c;/*tag=CHAR 时，为字符型*/
};
} TElemType;
/*二叉树的二叉链表存储表示 */
typedef struct BiTNode
{
TElemType data;
struct BiTNode *lchild,*rchild; /* 左右孩子指针 */
}BiTNode,*BiTree;
二叉树的基本操作已经在构造表达式和表达式中的基本操作中根据不同的功能和实际
情况修改了，详细见各个函数操作的算法设计。
2、顺序栈的存储类型
/*栈的顺序存储表示 */
#define STACK_INIT_SIZE 10 /* 存储空间初始分配量 */
#define STACKINCREMENT 2 /* 存储空间分配增量 */
/*两个顺序栈*/
typedef struct SqStack
{
SElemType *base; /* 在栈构造之前和销毁之后，base 的值为NULL */
SElemType *top; /* 栈顶指针 */
int stacksize; /* 当前已分配的存储空间，以元素为单位 */
}SqStack; /* 顺序栈SqStack */
typedef struct SqStack1
{
SElemType1 *base; /* 在栈构造之前和销毁之后，base的值为NULL */
SElemType1 *top; /* 栈顶指针 */
int stacksize; /* 当前已分配的存储空间，以元素为单位 */
}SqStack1; /* 顺序栈SqStack1 */
相关的基本操作见上面的“expression.h文件的整体结构”的说明，详细的算法设计见附录的程序清单。
3、表达式的基本操作
Status Input_Expr(char *string,int flag);
/*以字符序列的形式输入语法正确的前缀表达式，保存到字符串string*/
/*参数flag=0表示输出的提示信息是"请输入正确的前缀表示式："*/
/*flag=1表示输出的提示信息为"请以表达式的原书写形式输入正确表示式："*/ void judge_value(BiTree *E,char *string,int i);
/*判断字符string[i]，如果是'0'-'9'常量之间，二叉树结点存为整型；否则，存为字符型*/
Status ReadExpr(BiTree *E,char *exprstring);
/*以正确的前缀表示式并构造表达式E*/
Status Pri_Compare(char c1,char c2);
/*如果两个字符是运算符，比较两个运算符的优先级，c1比c2优先，返回OK，否则返回ERROR*/
void WriteExpr(BiTree E);
/*用带括弧的中缀表达式输入表达式*/
void Assign(BiTree *E,char V,int c,int *flag);
/*实现对表达式中的所有变量V的赋值(V=c)，参数flag为表示是否赋值过的标志*/ long Operate(int opr1,char opr,int opr2);
/*运算符运算求值，参数opr1,opr2为常量，opr为运算符，根据不同的运算符，实现不同的运算，返回运算结果*/
Status Check(BiTree E);
/*检查表达式是否还存在没有赋值的变量，以便求算数表达式的值*/
long Value(BiTree E);
/*对算术表达式求值*/
void CompoundExpr(char P,BiTree *E1,BiTree E2);
/*构造一个新的复合表达式*/
Status Read_Inorder_Expr(char *string,char *pre_expr);
/*以表达式的原书写形式输入，表达式的原书写形式字符串string变为字符串pre_expr，后调用reversal_string()函数反转得到前缀表达式pre_expr*/
下面列出部分基本操作的伪码算法，未列出的请见程序清单。
其中部分基本操作的伪码算法如下：
Status Input_Expr(char *string,int flag)
{
if(flag==0)printf("\n请输入正确的前缀表示式：");
else printf("\n请以表达式的原书写形式输入正确表示式：");
flushall();/*清理缓冲区*/
gets(string);/*从键盘输入一串字符串作为表达式*/
if(strlen(string)==1)/*输入的表达式字符串长度为1*/
{
if(string[0]=='+'||string[0]=='-'||string[0]=='*'||string[0]=='/'||string[0 ]=='^')/*输入的表达式只有一个运算符*/
{
printf("\n表达式只有运算符，错误！");
return ERROR;
}
else
if((string[0]>='0'&&string[0]<'9')||(string[0]>='a'&&string[0]<='z')||(string[0 ]>='A'&&string[0]<='Z'))/*输入的表达式只有一个数字或字符*/
{
printf("\n表达式只有一个字符！");
return OK;
}
else
{
printf("\n输入的字符不是运算符也不是变量常量，错误！");
return ERROR;
}
}
return OK;
}
void judge_value(BiTree *E,char *string,int i)
{
if(string[i]>='0' && string[i]<='9')/*为常量*/
{
(*E)->data.tag=INT;
(*E)->data.num=string[i]-48;
}
else if(string[i]>=1 && string[i]<=20)/*为常量，常量存于数组save_number 中*/
{
(*E)->data.tag=INT;
(*E)->data.num=save_number[string[i]];
}
else/*为变量*/
{
(*E)->data.tag=CHAR;
(*E)->data.c=string[i];
}
}
Status ReadExpr(BiTree *E,char *exprstring)
{
SqStack S;
int i,len;/*len为表达式的长度*/
BiTree p,q;
(*E)=(BiTree)malloc(sizeof(BiTNode));/*申请二叉树的根结点的空间*/
(*E)->lchild=NULL;
(*E)->rchild=NULL;
len=strlen(exprstring);/*len赋值为表达式的长度*/
if(len==1)/*表达式长度为1时，二叉树只有根结点*/
{
judge_value(E,exprstring,0);/*将exprstring[0]存入二叉树的结点中*/ }
else
{
judge_value(E,exprstring,0);/*将exprstring[0]存入二叉树的结点中*/
InitStack(&S);/*初始化栈*/
q=(*E);
Push(&S,q);/*入栈*/
Push(&S,q);/*入栈，根结点入栈两次是为判断先序输入的表达式是不是正确的表达式*/
for(i=1; i { p=(BiTree)malloc(sizeof(BiTNode)); judge_value(&p,exprstring,i);/*将exprstring[i]存入二叉树的结点中*/ p->lchild=NULL; p->rchild=NULL; if(exprstring[i]=='+' || exprstring[i]=='-' || exprstring[i]=='*' || exprstring[i]=='/' || exprstring[i]=='^') {/*为运算符，运算符入栈，左孩子不空，向左孩子走，否则，如果右孩子不空，向右孩子走*/ if(!q->lchild) { q->lchild=p; Push(&S,p); q=p; } else { q->rchild=p; Push(&S,p); q=p; } } else/*不是运算符，运算符出栈*/ { if(!q->lchild) { q->lchild=p; Pop(&S,&q); } else { q->rchild=p; Pop(&S,&q); } } } if(StackEmpty(S)&&i>=len) { return OK;/*栈空且i>=len，说明输入的表达式是正确的*/ } else /*输入的表达式是错误的*/ { printf("\n输入的表达式有误！"); return ERROR; } } } Status Pri_Compare(char c1,char c2) { if((c1=='^'||c1=='*'||c1=='-'||c1=='+'||c1=='/')&&(c2=='^'||c2=='*'||c2=='-'||c2=='+'||c2=='/')) { if(c1=='^') { if(c2!='^') return OK; else return ERROR; } else if(c1=='*'||c1=='/') { if(c2=='^'||c2=='*'||c2=='/') return ERROR; else return OK; } else return ERROR; } else return ERROR;/*c1和c2不是运算符*/ } void WriteExpr(BiTree E) { if(E)/*树不为空*/ { /*先递归左子树*/ if( E->lchild && E->lchild->data.tag==CHAR )/*E的左孩子不为空，且左孩子为字符*/ { if(Pri_Compare(E->data.c,E->lchild->data.c))/*E->data.c比E->lchild->data.c优先*/ { printf("("); WriteExpr(E->lchild); printf(")"); }/*带括弧输出左子树*/ else { WriteExpr(E->lchild);/*否则，不带括弧输出左子树*/ } } else { WriteExpr(E->lchild); }/*否则，输出左子树*/ if(E->data.tag==INT)/*访问输出根结点的值*/ { printf("%d",E->data.num); } else { printf("%c",E->data.c); } /*后递归右子树*/ if(E->rchild&&E->rchild->data.tag==CHAR)/*E的右孩子不为空，且右孩子为字符*/ { if(Pri_Compare(E->data.c,E->rchild->data.c))/*E->data.c比E->rchild->data.c优先*/ { printf("("); WriteExpr(E->rchild); printf(")"); }/*带括弧输出右子树*/ else { WriteExpr(E->rchild); }/*否则，不带括弧输出右子树*/ } else { WriteExpr(E->rchild); }/*否则，输出右子树*/ } } void Assign(BiTree *E,char V,int c,int *flag) { if(*E) { if((*E)->data.tag==CHAR && (*E)->data.c==V)/*如果找到要赋值的变量，赋值*/ { (*E)->data.tag=INT; (*E)->data.num=c; *flag=1; } Assign(&((*E)->lchild),V,c,flag);/*递归左子树*/ Assign(&((*E)->rchild),V,c,flag);/*递归左子树*/ } } long power(int x,int exp)/*指数运算函数，底数为x，指数为exp*/ { long result; int i; for(i=1,result=1;i<=exp;i++) result*=x; return result; } long Operate(int opr1,char opr,int opr2) { long result; switch(opr) { case '+': result=opr1+opr2; return result; break; case '-': result=opr1-opr2; return result; break; case '*': result=opr1*opr2; return result; break; case '/': result=opr1/opr2; return result; break; case '^': result=power(opr1,opr2); return result; break; default: break; } } Status Check(BiTree E) { if(E&&E->data.tag==CHAR)/*树不为空*/ { if(E->data.c!='*'&&E->data.c!='^'&&E->data.c!='-'&&E->data.c!='+'&&E->data. c!='/') { printf("\n表达式中仍存在没有赋值的变量!"); return ERROR; } if(Check(E->lchild))/*递归左子树*/ { Check(E->rchild);/*递归右子树*/ } } } long Value(BiTree E) { if(E)/*树不为空*/ { if(!E->lchild && !E->rchild && E->data.tag==INT) return (E->data.num); /*结点的左孩子和右孩子为空，为叶子结点，返回结点的值*/ return Operate(Value(E->lchild),E->data.c,Value(E->rchild)); /*运算求值，后根遍历的次序对表达式求值，其中参数递归调用了Value()函数求左子树的值和右子树的值*/ } } void CompoundExpr(char P,BiTree *E1,BiTree E2)/*构造一个新的复合表达式======================================CompoundExpr==============*/ { BiTree E; E=(BiTree)malloc(sizeof(BiTNode));/*申请一个结点存放运算符P*/ E->data.tag=CHAR; E->data.c=P;/*申请到的结点值为P*/ E->lchild=(*E1);/*结点的左孩子为E1*/ E->rchild=E2;/*结点的右孩子为E2*/ (*E1)=E;/*(*E1)为根结点*/ printf("\n表达式E复合成功！其表达式变为: "); WriteExpr(E);/*输出复合好的表达式*/ } Status Read_Inorder_Expr(char *string,char *pre_expr) { int i,j,len,char_number=1;/*len表示字符串string的长度，char_number是记录数组save_number[]的个数*/ int number;/*保存大于9的常量*/ char c,c1; SqStack1 S;/*栈定义*/ InitStack1(&S);/*初始栈*/ Push1(&S,'#');/*先将字符'#'入栈，用来表示作为栈的最底一个元素*/ len=strlen(string);/*len为字符串string的长度*/ c=string[len-1];/*从字符串的最后一个字符开始向前扫描*/ i=len-1; while(!StackEmpty1(S)&&i>=0)/*栈不为空且i大于等于0*/ { if(c=='(')/*字符为'('*/ { Pop1(&S,&c);/*出栈，赋值给c*/ while(c!=')')/*假如c不为')',出栈*/ { *pre_expr++=c; if(!StackEmpty1(S)&&GetTop1(S,&c1)&&c1!='#') Pop1(&S,&c); else { printf("\n输入的表达式有误!"); return ERROR; } } } else if(c==')')/*字符为')'，入栈*/ { Push1(&S,c); } else if(c>='0'&&c<='9')/*字符为'0'-'9'之间，循环扫描string前一个字符，后确定常量的大小*/ { number=c-48;/*number为第一个常量字符的ASCII码-48*/ for(c1=string[i-1],j=1;(c1>='0'&&c1<='9')&&i>=0;j++,i--)/*循环扫描string前一个字符，求出常量后赋给number*/ { number=(c1-48)*power(10,j)+number;/*number为扫描到的常量*/ c1=string[i-2]; } save_number[char_number]=number;/*将number存入到数组save_number中，下标为char_number*/ *pre_expr++=char_number++; } else if((c>='a'&&c<='z')||(c>='A'&&c<='Z'))/*字符为'a'-'z'或'A'-'Z'之间的变量*/ {/*string下一个字符不能为常量或变量，否则，出错*/ if((string[i-1]>='0'&&string[i-1]<='9')||(string[i-1]>='A'&&string[i-1]<='Z ')||(string[i-1]>='a'&&string[i-1]<='z')) { printf("\n输入的表达式有误！"); return ERROR; } else *pre_expr++=c; } else if(c=='*'||c=='/')/*字符为运算符'*'或'/'*/ { while(GetTop1(S,&c1)&&(c1=='^'))/*将c与栈顶的字符c1比较优先级*/ { Pop1(&S,&c1); *pre_expr++=c1; }/*如果c1比c优先，出栈*/ Push1(&S,c);/*入栈字符c*/ } else if(c=='+'||c=='-')/*字符为运算符'+'或'-'*/ { while(GetTop1(S,&c1)&&(c1=='^'||c1=='*'||c1=='/'))/*将c与栈顶的字符c1比较优先级*/ { Pop1(&S,&c1); *pre_expr++=c1; }/*如果c1比c优先，出栈*/ Push1(&S,c);/*入栈运算符c*/ } else if(c=='^')/*字符为运算符'^'*/ { Push1(&S,c);/*入栈运算符'^'*/ } else { printf("\n输入的表达式有误！"); return ERROR; }/*其他字符，错误，返回ERROR*/ i--;/*下一个字符*/ if(i>=0) c=string[i];/*i不小于0，c=string[i]循环下一个字符*/ else /*否则，将清空栈*/ while(!StackEmpty1(S)&&GetTop1(S,&c1)&&c1!='#') { Pop1(&S,&c); *pre_expr++=c; } } Pop1(&S,&c);/*将'#'出栈*/ *pre_expr='\0';/*字符串结束符*/ if(i<0&&StackEmpty1(S))return OK; else return ERROR; } void reversal_string(char *exprstring) /*将字符串exprstring反转过来*/ { int len,i,j; char temp; len=strlen(exprstring);/*len为exprstring的长度*/ for(i=0,j=len-1;i { temp=exprstring[i]; exprstring[i]=exprstring[j]; exprstring[j]=temp; } } 4、主程序和其他伪码算法 void main() { BiTree E,E1;/*两个表达式E和E1*/ int flag=0;/*表达式E构造标志，为0表示未构造，为1表示已构造*/ long result;/*保存算数表达式运算结果*/ char V,P; int c; char string[30]; char choice; printf("\n\t============表达式类型的实现============="); printf("\n\t 1:输入正确的前缀表达式"); printf("\n\t 2:输出带括弧的中缀表示式"); printf("\n\t 3:对变量进行赋值"); printf("\n\t 4:对算数表达式求值"); printf("\n\t 5:构造一个新的复合表达式"); printf("\n\t 0:退出"); printf("\n\t========================================="); while(1) { printf("\n\t请输入你的选择: "); choice=getche(); switch(choice) { case '1':/*1 >>>输入正确的前缀表达式*/ if(Input_Expr(Expr_String,0)) if(ReadExpr(&E,Expr_String)) { flag=1; printf("输入的带括弧的中缀表达式："); WriteExpr(E); } getch(); break; case '2':/*2 >>>带括弧的中缀表示式输出*/ if(flag==1) { printf("\n带括弧的中缀表达式为："); WriteExpr(E); } else { printf("\n表达式未构造成功！请重新构造表达式！"); } getch(); break; case '3':/*3 >>>对变量进行赋值*/ if(flag==1) { int Assign_flag=0; printf("\n表达式E为:"); WriteExpr(E); flushall();/*清理缓冲区*/ printf("\n请输入要赋值的值:"); V=getchar(); printf("请输入要将赋值为:"); scanf("%d",&c); Assign(&E,V,c,&Assign_flag); if(Assign_flag) { printf("\n赋值成功！\n赋值后的表达式为:"); WriteExpr(E); } else printf("\n表达式里没有%c这个变量！",V); } else printf("\n表达式未构造成功！请重新构造表达式！"); getch(); break; case '4':/*4 >>>对算数表达式求值*/ if(flag==1) { printf("\n算数表达式:"); WriteExpr(E); if(Check(E)) { result=Value(E); printf("\n求算数表达式的值:\t"); WriteExpr(E); printf("=%ld",result); } } else printf("\n表达式未构造成功！请重新构造表达式！"); getch(); break; case '5':/*5 >>>构造一个新的复合表达式*/ if(flag==1) { printf("\n表达式E1为:"); WriteExpr(E); printf("\n请构造新的表达式E2:"); flushall();/*清理缓冲区*/ if(Input_Expr(string,1)) { if(Read_Inorder_Expr(string,Expr_String)) { reversal_string(Expr_String); if(ReadExpr(&E1,Expr_String)) { flag=1;printf("\n表达式E1构造成功！");WriteExpr(E1); printf("\n请输入要构造新的复合表达式的操作运算符:"); P=getchar(); while(P!='*'&&P!='/'&&P!='+'&&P!='-'&&P!='^') { flushall();/*清理缓冲区*/ printf("\n输入的操作运算符有误！请重新输入."); P=getchar(); } CompoundExpr(P,&E,E1); } else printf("\n复合新的表达式失败！请按任意键返回主菜单！"); } } } else printf("\n表达式未构造成功！请重新构造表达式！"); getch(); break; case '0':/*0 >>>退出*/ printf("\n请按任意键退出！"); getch(); exit(0); default : printf("\n输入有误！请按任意键回到主菜单重新选择！"); getch(); break; } } } 5、函数的调用关系 除了主函数main()外，其他各个函数相对于其它函数来说是独立的，函数的使用都由主函数main()调用使用的，可以简单的说，各个函数都是主函数下的从函数。 四、调试分析 1、在起初设计上，针对前缀表达式的要求构造表达式E，常量的范围限定在0-9之间，后在这个构造表达式的架构上逐个逐个实现对表达式上的操作；后扩展到以表达式的原书写形式输入，整体架构是不变的，只是增加一些细节的处理功能。这样的设计从开始到最后都处于可扩展的模块化设计。 2、在对各个功能操作的实现上，时间复杂度大多数是O(n)，空间上增加了辅助栈，空间复杂度为O(n+s)。而在以原表达式形式输入操作上，实际上是对字符串的操作，将一串原表达式字符串处理为前缀表达式字符串而已，算法时间复杂度取决于输入的字符串的长度n，即O(n)，空间复杂度为O(2n+s)。整体的算法设计没有什么可取之处，对于减少时间复杂度和空间复杂度上没有什么细细考虑。 3、在调试的过程中，花费时间最为多的是对输入错误表达式的出错处理，更改增加的代码几乎都是为了出错处理. 五、用户手册 1、本程序的运行环境为DOS操作系统，执行文件为：tree.exe； 2、进入演示程序后首先出现一个主菜单，主菜单界面如下： 3、之后输入你的选择，进入你所要进行的操作中。 六、测试结果 1、 2、 3、 4、 5、 《数据结构课程实验》大纲 一、《数据结构课程实验》的地位与作用 “数据结构”是计算机专业一门重要的专业技术基础课程，是计算机专业的一门核心的关键性课程。本课程较系统地介绍了软件设计中常用的数据结构以及相应的存储结构和实现算法，介绍了常用的多种查找和排序技术，并做了性能分析和比较，内容非常丰富。本课程的学习将为后续课程的学习以及软件设计水平的提高打下良好的基础。 由于以下原因，使得掌握这门课程具有较大的难度： （1）内容丰富，学习量大，给学习带来困难； （2）贯穿全书的动态链表存储结构和递归技术是学习中的重点也是难点； （3）所用到的技术多，而在此之前的各门课程中所介绍的专业性知识又不多，因而加大了学习难度； （4）隐含在各部分的技术和方法丰富，也是学习的重点和难点。 根据《数据结构课程》课程本身的技术特性，设置《数据结构课程实验》实践环节十分重要。通过实验实践内容的训练，突出构造性思维训练的特征, 目的是提高学生组织数据及编写大型程序的能力。实验学时为18。 二、《数据结构课程实验》的目的和要求 不少学生在解答习题尤其是算法设计题时，觉得无从下手，做起来特别费劲。实验中的内容和教科书的内容是密切相关的，解决题目要求所需的各种技术大多可从教科书中找到，只不过其出现的形式呈多样化，因此需要仔细体会，在反复实践的过程中才能掌握。 为了帮助学生更好地学习本课程，理解和掌握算法设计所需的技术，为整个专业学习打好基础，要求运用所学知识，上机解决一些典型问题，通过分析、设计、编码、调试等各环节的训练，使学生深刻理解、牢固掌握所用到的一些技术。数据结构中稍微复杂一些的算法设计中可能同时要用到多种技术和方法，如算法设计的构思方法，动态链表，算法的编码，递归技术，与特定问题相关的技术等，要求重点掌握线性链表、二叉树和树、图结构、数组结构相关算法的设计。在掌握基本算法的基础上，掌握分析、解决实际问题的能力。 三、《数据结构课程实验》内容 课程实验共18学时，要求完成以下六个题目： 实习一约瑟夫环问题（2学时） 实验三二叉树的遍历 一、实验目的 １、熟悉二叉树的结点类型和二叉树的基本操作。 ２、掌握二叉树的前序、中序和后序遍历的算法。 3、加深对二叉树的理解，逐步培养解决实际问题的编程能力。 二、实验环境 运行Ｃ或VC++的微机。 三、实验内容 1、依次输入元素值，以链表方式建立二叉树，并输出结点的值。 2、分别以前序、中序和后序遍历二叉树的方式输出结点内容。 四、设计思路 1. 对于这道题，我的设计思路是先做好各个分部函数，然后在主函数中进行顺序排列，以此完成实验要求 2．二叉树采用动态数组 3.二叉树运用9个函数，主要有主函数、构建空二叉树函数、建立二叉树函数、访问节点函数、销毁二叉树函数、先序函数、中序函数、后序函数、范例函数，关键在于访问节点 五、程序代码 #include int data; //数据域 struct TNode *lchild,*rchild; // 指针域包括左右孩子指针 }TNode,*Tree; void CreateT(Tree *T)//创建二叉树按,依次输入二叉树中结点的值 { int a; scanf("%d",&a); if(a==00) // 结点的值为空 *T=NULL; else // 结点的值不为空 { *T=(Tree)malloc(sizeof(TNode)); if(!T) { printf("分配空间失败！！TAT"); exit(ERROR); } (*T)->data=a; CreateT(&((*T)->lchild)); // 递归调用函数，构造左子树 CreateT(&((*T)->rchild)); // 递归调用函数，构造右子树 } } void InitT(Tree *T)//构建空二叉树 { T=NULL; } void DestroyT(Tree *T)//销毁二叉树 { if(*T) // 二叉树非空 { DestroyT(&((*T)->lchild)); // 递归调用函数，销毁左子树 DestroyT(&((*T)->rchild)); // 递归调用函数，销毁右子树 free(T); T=NULL; } } void visit(int e)//访问结点 { printf("%d ",e); } 数据结构实验报告 一．题目要求 1）编程实现二叉排序树，包括生成、插入，删除； 2）对二叉排序树进行先根、中根、和后根非递归遍历； 3）每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。 4）分别用二叉排序树和数组去存储一个班(50人以上)的成员信息(至少包括学号、姓名、成绩3项),对比查找效率，并说明在什么情况下二叉排序树效率高,为什么? 二．解决方案 对于前三个题目要求，我们用一个程序实现代码如下 #include 树和二叉树 一、实验目的 1.掌握二叉树的结构特征，以及各种存储结构的特点及适用范围。 2.掌握用指针类型描述、访问和处理二叉树的运算。 二、实验要求 1.认真阅读和掌握本实验的程序。 2.上机运行本程序。 3.保存和打印出程序的运行结果，并结合程序进行分析。 4.按照二叉树的操作需要，重新改写主程序并运行，打印出文件清单和运 行结果。 三、实验内容 1.输入字符序列，建立二叉链表。 2.按先序、中序和后序遍历二叉树（递归算法）。 3.按某种形式输出整棵二叉树。 4.求二叉树的高度。 5.求二叉树的叶节点个数。 6.交换二叉树的左右子树。 7.借助队列实现二叉树的层次遍历。 8.在主函数中设计一个简单的菜单，分别调试上述算法。 为了实现对二叉树的有关操作，首先要在计算机中建立所需的二叉树。建立二叉树有各种不同的方法。一种方法是利用二叉树的性质5来建立二叉树，输入数据时要将节点的序号（按满二叉树编号）和数据同时给出：（序号，数据元素0）。另一种方法是主教材中介绍的方法，这是一个递归方法，与先序遍历有点相似。数据的组织是先序的顺序，但是另有特点，当某结点的某孩子为空时以字符“#”来充当，也要输入。若当前数据不为“#”，则申请一个结点存入当前数据。递归调用建立函数，建立当前结点的左右子树。 四、解题思路 1、先序遍历：○1访问根结点，○2先序遍历左子树，○3先序遍历右子树 2、中序遍历：○1中序遍历左子树，○2访问根结点，○3中序遍历右子树 3、后序遍历：○1后序遍历左子树，○2后序遍历右子树，○3访问根结点 4、层次遍历算法：采用一个队列q，先将二叉树根结点入队列，然后退队列，输出该结点；若它有左子树，便将左子树根结点入队列；若它有右子树，便将右子树根结点入队列，直到队列空为止。因为队列的特点是先进后出，所以能够达到按层次遍历二叉树的目的。 五、程序清单 #include 数据结构实验报告全集 实验一线性表基本操作和简单程序 1．实验目的 （1）掌握使用Visual C++ 6.0上机调试程序的基本方法； （2）掌握线性表的基本操作：初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。 2．实验要求 （1）认真阅读和掌握和本实验相关的教材内容。 （2）认真阅读和掌握本章相关内容的程序。 （3）上机运行程序。 （4）保存和打印出程序的运行结果，并结合程序进行分析。 （5）按照你对线性表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果 实验代码： 1）头文件模块 #include iostream.h>//头文件 #include nodetype *create()//建立单链表，由用户输入各结点data域之值，//以0表示输入结束 { elemtype d;//定义数据元素d nodetype *h=NULL,*s,*t;//定义结点指针 int i=1; cout<<"建立一个单链表"< 二叉树的建立和遍历的实验报告 篇一：二叉树的建立及遍历实验报告 实验三：二叉树的建立及遍历 【实验目的】 （1）掌握利用先序序列建立二叉树的二叉链表的过程。 （2）掌握二叉树的先序、中序和后序遍历算法。 【实验内容】 1. 编写程序，实现二叉树的建立，并实现先序、中序和后序遍历。 如：输入先序序列abc###de###，则建立如下图所示的二叉树。 并显示其先序序列为：abcde 中序序列为：cbaed 后序序列为：cbeda 【实验步骤】 1.打开VC++。 2.建立工程：点File->New，选Project标签，在列表中选Win32 Console Application，再在右边的框里为工程起好名字，选好路径，点OK->finish。至此工程建立完毕。 3.创建源文件或头文件：点File->New，选File标签，在列表里选C++ Source File。给文件起好名字，选好路径，点OK。至此一个源文件就被添加到了你刚创建的工程之中。 4．写好代码 5．编译－＞链接－＞调试 #include #include #define OK 1 #define OVERFLOW -2 typedef int Status; typedef char TElemType; typedef struct BiTNode { TElemType data; struct BiTNode *lchild, *rchild; }BiTNode,*BiTree; Status CreateBiTree(BiTree &T) { TElemType ch; scanf("%c",&ch); if (ch=='#') T= NULL; else { if (!(T = (BiTNode *)malloc(sizeof(BiTNode)))) 《数据结构》第六次实验报告 学生姓名 学生班级 学生学号 指导老师 一、实验内容 1) 采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序 以及按层次遍历的操作，求所有叶子及结点总数的操作。 2) 输出树的深度，最大元，最小元。 二、需求分析 遍历二叉树首先有三种方法，即先序遍历，中序遍历和后序遍历。 递归方法比较简单，首先获得结点指针如果指针不为空，且有左子，从左子递归到下一层，如果没有左子，从右子递归到下一层，如果指针为空，则结束一层递归调用。直到递归全部结束。 下面重点来讲述非递归方法： 首先介绍先序遍历： 先序遍历的顺序是根左右，也就是说先访问根结点然后访问其左子再然后访问其右子。具体算法实现如下：如果结点的指针不为空，结点指针入栈，输出相应结点的数据，同时指针指向其左子，如果结点的指针为空，表示左子树访问结束，栈顶结点指针出栈，指针指向其右子，对其右子树进行访问，如此循环，直至结点指针和栈均为空时，遍历结束。 再次介绍中序遍历： 中序遍历的顺序是左根右，中序遍历和先序遍历思想差不多，只是打印顺序稍有变化。具体实现算法如下：如果结点指针不为空，结点入栈，指针指向其左子，如果指针为空，表示左子树访问完成，则栈顶结点指针出栈，并输出相应结点的数据，同时指针指向其右子，对其右子树进行访问。如此循环直至结点指针和栈均为空，遍历结束。 最后介绍后序遍历： 后序遍历的顺序是左右根，后序遍历是比较难的一种，首先需要建立两个栈，一个用来存放结点的指针，另一个存放标志位，也是首先访问根结点，如果结点的指针不为空，根结点入栈，与之对应的标志位也随之入标志位栈，并赋值0，表示该结点的右子还没有访问，指针指向该结点的左子，如果结点指针为空，表示左子访问完成，父结点出栈，与之对应的标志位也随之出栈，如果相应的标志位值为0，表示右子树还没有访问，指针指向其右子，父结点再次入栈，与之对应的标志位也入栈，但要给标志位赋值为1，表示右子访问过。如果相应的标志位值为1，表示右子树已经访问完成，此时要输出相应结点的数据，同时将结点指针赋值为空，如此循环直至结点指针和栈均为空，遍历结束。 三、详细设计 源代码： 2009级数据结构实验报告 实验名称：约瑟夫问题 学生姓名：李凯 班级：21班 班内序号：06 学号：09210609 日期：2010年11月5日 1．实验要求 1）功能描述：有n个人围城一个圆圈，给任意一个正整数m，从第一个人开始依次报数，数到m时则第m个人出列，重复进行，直到所有人均出列为止。请输出n个人的出列顺序。 2）输入描述：从源文件中读取。 输出描述：依次从显示屏上输出出列顺序。 2. 程序分析 1）存储结构的选择 单循环链表 2）链表的ADT定义 ADT List{ 数据对象：D={a i|a i∈ElemSet,i=1,2,3,…n,n≧0} 数据关系：R={< a i-1, a i>| a i-1 ,a i∈D,i=1,2,3,4….,n} 基本操作： ListInit(&L)；//构造一个空的单链表表L ListEmpty(L); //判断单链表L是否是空表，若是，则返回1，否则返回0. ListLength(L); //求单链表L的长度 GetElem（L，i）；//返回链表L中第i个数据元素的值； ListSort(LinkList [内容要求] 1、存储结构：顺序表、单链表或其他存储结构，需要画示意图，可参考书上P59 页图2-9 2.2 关键算法分析 结点类： template 重庆交通大学综合性设计性实验报告 姓名姚远学号 631106060113 班级：计信息一班 实验项目名称：二叉树 实验项目性质：设计性实验 实验所属课程：数据结构 实验室(中心)： 407机房 指导教师：鲁云平 实验完成时间： 2013 年 5 月 10 日 一、实验目的 1. 建立二叉树 2. 计算结点所在的层次 3.统计结点数量和叶结点数量 4.计算二叉树的高度 5.计算结点的度 6.找结点的双亲和子女 7.二叉树的遍历 8.二叉树的输出等等 二、实验内容及要求 1.二叉树的结点结构,二叉树的存储结构由学生自由选择和设定 2.实验完成后上交打印的实验报告,报告内容与前面所给定的实验模板相同 3.将实验报告电子版和源代码在网络教学平台提交 三、实验设备及软件 VISUAL C++软件 四、设计方案 ㈠题目（老师给定或学生自定） 二叉树的应用 ㈡设计的主要思路 在计算机科学中，二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用作二叉查找树和二叉堆或是二叉排序树。二叉树的每个结点至多只有二棵子树(不存在出度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2的i -1次方个结点；深度为k的二叉树至多有2^(k) -1个结点；对任何一棵二叉树T，如果其终端结点数(即叶子结点数)为n0，出度为2的结点数为n2，则n0 =n2 + 1。 ㈢主要功能 实现二叉树的各项操作。 五、主要代码 #include 实验题目：实验九——二叉树实验 算法设计（3） 问题分析： 1、题目要求：编写算法交换二叉树中所有结点的左右子树 2、设计思路：首先定义一个二叉树的数据类型，使用先序遍历建立该二叉树，遍历二叉树，设计左右子树交换的函数，再次遍历交换之后的二叉树，与先前二叉树进行比较。遍历算法与交换算法使用递归设计更加简洁。 3、测试数据： A、输入：1 2 4 0 0 5 0 0 3 0 0 交换前中序遍历：4 2 5 1 3 交换后中序遍历：3 1 5 2 4 交换前：交换后： B、输入：3 7 11 0 0 18 17 0 0 19 0 0 6 13 0 0 16 0 0 交换前中序遍历：11 7 17 18 19 3 13 6 16 交换后中序遍历：16 6 13 3 19 18 17 7 11 概要设计： 1、为了实现上述功能：①构造一个空的二叉树；②应用先序遍历输入，建立二叉树；③中序遍历二叉树；④调用左右子树交换函数；⑤中序遍历交换过后的二叉树。 2、本程序包括4个函数： ①主函数main（） ②先序遍历二叉树建立函数creat_bt（） ③中序遍历二叉树函数inorder（） ④左右子树交换函数 exchange（） 各函数间关系如下： 详细设计： 1、结点类型 typedef struct binode //定义二叉树 { int data; //数据域 struct binode *lchild,*rchild; //左孩子、右孩子 }binode,*bitree; 2、各函数操作 ① 先序遍历建二叉树函数 bitree creat_bt() { 输入结点数据； 判断是否为0{ 若是，为空； 不是，递归；} 返回二叉树； } ② 左右子树交换函数 void exchange(bitree t) { 判断结点是否为空{ 否，交换左右子树； 递归；} } ③ 中序遍历函数 void inorder(bitree bt) { 判断是否为空{ 递归左子树； 输出； 递归右子树；} } main （） creat_bt （） inorder （） exchange （） ******************************* 实验题目：二叉树的操作 实验者信息：班级13007102，姓名庞文正，学号1300710226 实验完成的时间3:00 ****************************** 一、实验目的 1,掌握二叉树链表的结构和二叉树的建立过程。 2,掌握队列的先进先出的运算原则在解决实际问题中的应用。 3,进一步掌握指针变量、指针数组、动态变量的含义。 4,掌握递归程序设计的特点和编程方法。 二、实验内容 已知以二叉链表作存储结构，试编写按层次遍历二叉树的算法。（所谓层次遍历，是指从二叉树的根结点开始从上到下逐层遍历二叉树，在同一层次中从左到右依次访问各个节点。）调试程序并对相应的输出作出分析；修改输入数据，预期输出并验证输出的结果。加深对算法的理解。 三、算法设计与编码 1.本实验用到的理论知识 总结本实验用到的理论知识，实现理论与实践相结合。总结尽量简明扼要，并与本次实验密切相关，最好能加上自己的解释。 本算法要采用一个循环队列que，先将二叉树根结点入队列，然后退队列，输出该结点；若它有左子树，便将左子树根结点入队列；若它有右子树，便将右子树根结点入队列，直到队列空为止。因为队列的特点是先进先出，从而达到按层次顺序遍历二叉的目的。2.算法概要设计 给出实验的数据结构描述，程序模块、功能及调用关系 #include 题目： 编程实现二叉查找树的建立、中序遍历、元素查找等功能，要求解释实现过程及演示实际例子的运行结果。 算法描述： 首先创建二叉树结点类，其主要包括：二叉树结点数据域，指向左、右子树的指针，构造函数，设置当前结点左、右子树、数据域以及判断当前结点是否为叶子结点等。然后进行二叉树类定义，其私有部分为定义二叉树根结点指针，公有部分主要包括：构造函数、析构函数、判断二叉树是否为空树、先，中，后序遍历的递归与非递归、二叉树删除、层序遍历以及二叉树搜索等。接下来将对一些重要函数算法进行描述： 1、isLeaf函数：若该结点的左子树和右子树都为空，则为叶子结点。 2、isEmpty函数：根结点为空则为空树。 3、Parent函数：首先判断给定结点是否有双亲，根结点和空结点一定无双亲，初始化一个临时变量，用于跟进查找双亲结点，查找到后其保存的便是双亲结点。先递归在左子树中查找，如果找到，便结束递归且返回双亲结点指针；如果没有找到，再递归在右子树中查找。如果都没有找到，说明给定结点的双亲结点不在该二叉树中。 4、LeftSibling（RightSibling）函数：首先找到当前结点的双亲，然后判断双亲结点左右子树是否为空，其中必然有一个不为空，返回另一个子树指针即可。 5、DeleteBinaryTree函数：首先判断是否为空树，若为空，则返回，然后递归删除左子树，递归删除右子树，最后删除根结点。 6、PreOrder函数：首先判断是否为空树，若为空，则返回，然后访问根结点，递归遍历左子树，递归遍历右子树，结束。 7、PreOrderWithoutRecusion函数：使用栈来模拟递归过程，首先申请栈，用于保存结点指针序列，申请指针pointer保存当前根指针，然后判断栈是否为空，若栈为空且pointer为空，跳出函数，否则若pointer不为空，访问pointer所指结点，pointer入栈，pointer指向其左子树；若pointer为空，弹出栈顶元素赋给pointer，pointer指向其右子树，结束。 8、CreateTree函数：采用先序遍历序列构造二叉树，设‘0’为空结点，输入非‘0’数，生成新结点，递归创建左子树和右子树。 9、Search函数：采用先序遍历查找给定元素是否在二叉树中，首先判断树是否是空树，若是空树，则返回空指针。然后初始化临时指针temp，查找成功后temp即为所给元素所在 学生实验报告 学院：软通学院 课程名称：数据结构与算法 专业班级：软件142 班 姓名：邹洁蒙 学号： 0143990 学生实验报告 （二） 一、实验综述 1、实验目的及要求 目的：1）掌握树与二叉树的基本概念； 2）掌握二叉树的顺序存储，二叉链表的先序遍历中序遍历和后序遍历算法； 3）掌握树的双亲表示法。 要求：1）编程：二叉树的顺序存储实现； 2）编程：二叉链表的先序遍历中序遍历和后序遍历实现； 3）编程：树的双亲表示法实现。 2、实验仪器、设备或软件 设备：PC 软件：VC6 二、实验过程(编程，调试，运行；请写上源码，要求要有注释) 1.编程：二叉树的顺序存储实现 代码： BiTree::BiTree()//建立存储空间 { data = new int[MAXSIZE]; count = 0; } void BiTree::AddNode(int e)//加结点 { int temp = 0; data[count] = e; count++;//从编号0开始保存 } 运行截图： 2.编程：二叉链表的先序遍历中序遍历和后序遍历实现代码： void InOrderTraverse(BiTree* Head)//中序遍历 { if (Head) { InOrderTraverse(Head->LeftChild); cout << Head->data<<" "; InOrderTraverse(Head->RightChild); } } void PreOrderTraverse(BiTree* Head)//先序遍历 { if (Head) { cout << Head->data << " "; PreOrderTraverse(Head->LeftChild); PreOrderTraverse(Head->RightChild); } } void PostOrderTraverse(BiTree* Head)//后序遍历 { if (Head) { PostOrderTraverse(Head->LeftChild); PostOrderTraverse(Head->RightChild); cout << Head->data << " "; } } 运行截图： 算法与数据结构》课程实验报告 一、实验目的 1、实现二叉树的存储结构 2、熟悉二叉树基本术语的含义 3、掌握二叉树相关操作的具体实现方法 二、实验内容及要求 1. 建立二叉树 2. 计算结点所在的层次 3. 统计结点数量和叶结点数量 4. 计算二叉树的高度 5. 计算结点的度 6. 找结点的双亲和子女 7. 二叉树前序、中序、后序遍历的递归实现和非递归实现及层次遍历 8. 二叉树的复制 9. 二叉树的输出等 三、系统分析 （1）数据方面：该二叉树数据元素采用字符char 型，并且约定“ #”作为二叉树输入结束标识符。并在此基础上进行二叉树相关操作。 （2）功能方面：能够实现二叉树的一些基本操作，主要包括： 1. 采用广义表建立二叉树。 2. 计算二叉树高度、统计结点数量、叶节点数量、计算每个结点的度、结点所在层次。 3. 判断结点是否存在二叉树中。 4. 寻找结点父结点、子女结点。 5. 递归、非递归两种方式输出二叉树前序、中序、后序遍历。 6. 进行二叉树的复制。 四、系统设计 （1）设计的主要思路 二叉树是的结点是一个有限集合，该集合或者为空，或者是由一个根节点加上两棵分别称为左子树和右子树、互不相交的二叉树组成。根据实验要求，以及课上老师对于二叉树存储结构、基本应用的讲解，同时课后研究书中涉及二叉树代码完成二叉树模板类，并将所需实现各个功能代码编写完成，在建立菜单对功能进行调试。 （2）数据结构的设计 二叉树的存储结构有数组方式和链表方式。但用数组来存储二叉树有可能会消耗大量的存储空间，故在此选用链表存储，提高存储空间的利用率。根据二叉树的定义，二叉 2011~2012第一学期数据结构实验报告 班级：信管一班 学号：201051018 姓名：史孟晨 实验报告题目及要求 一、实验题目 设某班级有M（6）名学生，本学期共开设N（3）门课程，要求实现并修改如下程序（算法）。 1. 输入学生的学号、姓名和 N 门课程的成绩（输入提示和输出显示使用汉字系统）， 输出实验结果。（15分） 2. 计算每个学生本学期 N 门课程的总分，输出总分和N门课程成绩排在前 3 名学 生的学号、姓名和成绩。 3. 按学生总分和 N 门课程成绩关键字升序排列名次，总分相同者同名次。 二、实验要求 1．修改算法。将奇偶排序算法升序改为降序。（15分） 2．用选择排序、冒泡排序、插入排序分别替换奇偶排序算法,并将升序算法修改为降序算法；。（45分）） 3．编译、链接以上算法，按要求写出实验报告（25）。 4. 修改后算法的所有语句必须加下划线，没做修改语句保持按原样不动。 5．用A4纸打印输出实验报告。 三、实验报告说明 实验数据可自定义，每种排序算法数据要求均不重复。 (1) 实验题目：《N门课程学生成绩名次排序算法实现》； (2) 实验目的：掌握各种排序算法的基本思想、实验方法和验证算法的准确性； (3) 实验要求：对算法进行上机编译、链接、运行； (4) 实验环境（Windows XP-sp3,Visual c++)； (5) 实验算法（给出四种排序算法修改后的全部清单）； (6) 实验结果（四种排序算法模拟运行后的实验结果）； (7) 实验体会（文字说明本实验成功或不足之处）。 三、实验源程序（算法） Score.c #include "stdio.h" #include "string.h" #define M 6 #define N 3 struct student { char name[10]; int number; int score[N+1]; /*score[N]为总分,score[0]-score[2]为学科成绩*/ }stu[M]; void changesort(struct student a[],int n,int j) {int flag=1,i; struct student temp; while(flag) { flag=0; for(i=1;i 二叉树的创建与遍历 一、试验内容 根据输入的字符串创建树或二叉树，输出树或二叉树的先序遍历和后序遍历序列。 二、运行环境 Visual C++ 三、需求分析 1、建立一棵用二叉链表方式存储的二叉树。 2、从键盘接受扩展先序序列，以二叉链表作为存储结构。 3、建立二叉树，并将遍历结果打印输出。采用递归和非递归两种 方法实现。 四、设计概要 //——————二叉树的二叉链表存储表示—————— typedef struct BiTBode{ TElemType data; Struct BiTNode *lchild, *rchild //左右孩子指针 }BiTNode, *BiTree; //—————基本操作的函数原型说明———————— Status CreateBiTree(BiTree &T); //按先序次序输入二叉树中结点的值（一个字符），空格字符表示空树。 //构造二叉树链表表示的二叉树T。 Status PreOrderTraverse(BiTree T, status(*visit)(TElemType e)); //采用二叉链表存储结构，visit是对结点操作的应用函数。 //先序遍历二叉树T，对每个结点调用函数visit一次且仅以次。 //一旦visit（）失败，则操作失败。 Status PostOrderTraverse(BiTree T, status(*visit)(TElemType e)); //采用二叉链表存储结构，visit是对结点操作的应用函数。 //后序遍历二叉树T，对每个结点调用函数visit一次且仅以次。 //一旦visit（）失败，则操作失败。 —————先序遍历二叉树基本操作的递归算法———— Status PreOrderTraverse(BiTree T,Status(*visit)(TElemType e)){ //采用二叉链表存储结构，visit是对数据元素操作的应用函数， 实验六：二叉树及其应用 一、实验目的 树是数据结构中应用极为广泛的非线性结构，本单元的实验达到熟悉二叉树的存储结构的特性，以及如何应用树结构解决具体问题。 二、问题描述 首先，掌握二叉树的各种存储结构和熟悉对二叉树的基本操作。其次，以二叉树表示算术表达式的基础上，设计一个十进制的四则运算的计算器。 如算术表达式：a+b*(c-d)-e/f 三、实验要求 如果利用完全二叉树的性质和二叉链表结构建立一棵二叉树，分别计算统计叶子结点的个数。求二叉树的深度。十进制的四则运算的计算器可以接收用户来自键盘的输入。由输入的表达式字符串动态生成算术表达式所对应的二叉树。自动完成求值运算和输出结果。四、实验环境 PC微机 DOS操作系统或 Windows 操作系统 Turbo C 程序集成环境或 Visual C++ 程序集成环境 五、实验步骤 1、根据二叉树的各种存储结构建立二叉树； 2、设计求叶子结点个数算法和树的深度算法； 3、根据表达式建立相应的二叉树，生成表达式树的模块； 4、根据表达式树，求出表达式值，生成求值模块； 5、程序运行效果，测试数据分析算法。 六、测试数据 1、输入数据：2.2*（3.1+1.20）-7.5/3 正确结果：6.96 2、输入数据：(1+2)*3+(5+6*7); 正确输出：56 七、表达式求值 由于表达式求值算法较为复杂，所以单独列出来加以分析： 1、主要思路：由于操作数是任意的实数，所以必须将原始的中缀表达式中的操作数、操作符以及括号分解出来，并以字符串的形式保存；然后再将其转换为后缀表达式的顺序，后缀表达式可以很容易地利用堆栈计算出表达式的值。 例如有如下的中缀表达式： a+b-c 转换成后缀表达式为： ab+c- 然后分别按从左到右放入栈中，如果碰到操作符就从栈中弹出两个操作数进行运算，最后再将运算结果放入栈中，依次进行直到表达式结束。如上述的后缀表达式先将a 和b 放入栈中，然后碰到操作符“+”，则从栈中弹出a 和b 进行a+b 的运算，并将其结果d（假设为d）放入栈中，然后再将c 放入栈中，最后是操作符“-”，所以再弹出d和c 进行d-c 运算，并将其结果再次放入栈中，此时表达式结束，则栈中的元素值就是该表达式最后的运算结果。当然将原始的中缀表达式转换为后缀表达式比较关键，要同时考虑操作符的优先级以及对有括号的情况下的处理，相关内容会在算法具体实现中详细讨论。 图实验 一，邻接矩阵的实现 1.实验目的 （1）掌握图的逻辑结构 （2）掌握图的邻接矩阵的存储结构 （3）验证图的邻接矩阵存储及其遍历操作的实现 2.实验内容 （1）建立无向图的邻接矩阵存储 （2）进行深度优先遍历 （3）进行广度优先遍历 3．设计与编码 #ifndef MGraph_H #define MGraph_H const int MaxSize = 10; template 数据结构 实 验 报 告 1. 实验目的和内容： 掌握二叉树基本操作的实现方法2. 程序分析 2.1存储结构 链式存储 2．程序流程 2.3关键算法分析 算法一：Create(BiNode 算法三：PreOrder(BiNode数据结构实验报告格式
数据结构二叉树实验报告
数据结构实验报告
树和二叉树实验报告
数据结构实验报告全集
二叉树的建立和遍历的实验报告doc
数据结构实验报告-二叉树的实现与遍历
数据结构实验报告模板
二叉树实验报告及代码
二叉树实验报告
数据结构实验-二叉树的操作
二叉树实验报告
数据结构实验报告之树与二叉树
数据结构实验报告—二叉树
数据结构实验报告及心得体会
二叉树实验报告
数据结构实验二叉树
数据结构实验报告图实验
数据结构二叉树的实验报告