魔王语言数据结构实验报告课案
魔王语言解释-大数据结构课程设计
实习2、魔王语言解释一、需求分析1. 问题描述有一个魔王总是使用自己的一种非常精练而抽象的语言讲话，没人能听的懂，但他的语言是可以逐步解释成人能懂得语言的，因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的：（1）α->β1 β2 ... βn（2）(θδ1 δ2 ... δn) —>θδn θδn-1 ...θδ1 θ在这两种形式中，从左到右均表示解释。
试写一个魔王解释系统，把他的话解释成人能听懂得话。
2. 基本要求用下述两条具体规则和上述规则形式（2）实现。
设大写字母表示魔王语言的词汇；小写字母表示人的语言词汇；希腊字母表示可以用大写或小写字母代换的变量。
魔王语言可含人的词汇。
（1）B—>tAdA（2）A—>sae3. 测试数据B（ehnxgz）B 解释成tsaedsaeezegexenehetsaedsae若将小写字母与汉字建立下表所示的对应关系，则魔王说的话是“天上一个鹅地上一个鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一个鹅地上一个鹅”。
4. 实现提示将魔王的语言自右至左进栈，总是处理栈顶字符。
若是开括号，则逐一出栈，将字母顺序入队列，直至闭括号出栈，并按规则要求逐一出队列再处理后入栈。
其他情形较简单，请读者思考如何处理。
应首先实现栈和队列的基本操作。
二、概要设计1、设定栈的抽象数据类型定义：ADT Stack {数据对象：D= {a i| a i∈CharSet, i= 1,2,……n,. n≥0 }数据关系：R1={ <a i-1 ,a i> | a i-1,a i∈D, a i-1<a i ,i=1,2……,n}基本操作：InitStack(*S)操作结果：构造一个空栈。
Push(*S,e)初始条件：栈S已存在操作结果：在栈顶插入新的元素。
Pop(*S,*e)初始条件：栈S已存在操作结果：删除栈顶元素，并用e返回其值。
StackEmpty(S)初始条件：栈S已存在操作结果：若S为空栈，则返回1，否则返回0。
数据结构 课程设计报告 魔王语言解释
题目：魔王语言解释[问题描述]有一个魔王总是使用自己的一种非常精练而抽象的语言讲话，没有人能听懂，但他的语言是可以逐步解释成人能听懂的语言，因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的：（1）α->β1β2……βm（2）（θδ1δ2……δn）—>θδnθδn-1……θδ1θ在这两种形式中，从左到右均表示解释。
试写一个魔王语言的解释系统，把他的话解释成人能听得懂的话；[基本要求]用下述两条具体规则和上述规则形式（2）实现。
设大写字母表示魔王语言的词汇；小写字母表示人的语言词汇；希腊字母表示可以用大写字母或小写字母代换的变量。
魔王语言可含人的词汇。
（1）B->tAdA（2）A->sae[测试数据]B（ehnxgz）B解释成tsaedsaeezegexenehetsaedsae若将小写字母与汉字建立下表所示的对应关系，则魔王说的话是：“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。
[实现提示]将魔王的语言自右至左进栈，总是处理栈顶字符。
若是开括号，则逐一出栈，将字母顺序入队列，直至闭括号出栈，并按规则要求逐一出队列再处理后入栈。
其他情形较简单，请读者思考应如何处理。
应首先实现栈和队列的基本操作。
[源代码]#include<stdio.h>#include<stdlib.h>#define STACK_INIT_SIZE 100#define STACK_INCREMENT 10struct Stack{char* base;char* top;int stacksize;};void InitStack(struct Stack &s){//构造栈s.base=(char*)malloc(STACK_INIT_SIZE*sizeof(char));s.top=s.base;s.stacksize=STACK_INIT_SIZE;}void Push(struct Stack &s,char e){//压入元素if(s.top-s.base>=STACK_INIT_SIZE){s.base=(char*)realloc(s.base,(s.stacksize+STACK_INCREMENT)*sizeof(char));s.top=s.base+s.stacksize;s.stacksize+=STACK_INCREMENT;}*(s.top)=e;s.top++;}void Pop(struct Stack &s,char &e){//取出元素e=*--s.top;}int StackEmpty(struct Stack s){//栈是否为空if(s.top==s.base){return 1;}else{return 0;}}void ClearStack(struct Stack &s){s.top=s.base;}struct Queue{char data;struct Queue* next;};struct LinkQueue{struct Queue* front;struct Queue* rear;};void InitQueue(struct LinkQueue &q){//构造队q.front=q.rear=(struct Queue*)malloc(sizeof(struct Queue));q.front->next=NULL;}void EnQueue(struct LinkQueue &q,char e){//元素入队struct Queue* p;p=(struct Queue*)malloc(sizeof(struct Queue));p->data=e;p->next=NULL;q.rear->next=p;q.rear=p;}void DeQueue(struct LinkQueue &q,char &e){//元素出队struct Queue* p;p=q.front->next;e=p->data;q.front->next=p->next;if(q.rear==p){q.rear=q.front;}free(p);}int QueueEmpty(struct LinkQueue q){//队是否为空if(q.front==q.rear){return 1;}else{return 0;}}void InStack(char* ch,struct Stack &s){//把字符数组从右至左压入栈中int i,L=0;while(ch[L]!='\0'){L++;}for(i=L-1;i>=0;i--){Push(s,ch[i]);}}int main(){int i=0;char A[]="sae";char B[]="tsaedsae";char flag='0';//flag用来标记处理括号int mark=1;int f=0;struct Stack S;struct Stack temp;//用来处理括号外的元素InitStack(S);InitStack(temp);struct LinkQueue Q;InitQueue(Q);char MoWang[100]="\0";char e1,key,e2,e;printf("************************************************************** \n");printf("* * 欢迎光临广东工业大学**\n");printf("* **************************** *\n");printf("* * 魔王语言解释系统* *\n");printf("* **************************** *\n");printf("* 班级:计算机学院网络工程2007级4班*\n");printf("* 姓名: 黄文龙学号: 3107007087 *\n");printf("************************************************************** \n\n");printf("请输入你想要解释的魔王语言（最多含有一个括号）：\n");gets(MoWang);InStack(MoWang,S);//把要解释的魔王语言压入栈中while(!StackEmpty(S)){Pop(S,e1);if(e1=='('){if(StackEmpty(S)){printf("魔王语言错误!\n");mark=0;break;}while(!StackEmpty(S)){Pop(S,e1);if(e1==')'){f=1;break;}else if(!(e1>='a'&&e1<='z')&&!(e1>='A'&&e1<='Z')){ printf("魔王语言错误！\n");mark=0;break;}}if(mark==0){break;}if(f!=1){printf("魔王语言错误！\n");break;}}else if(e1==')'){printf("魔王语言错误！\n");mark=0;break;}else if(!(e1>='a'&&e1<='z')&&!(e1>='A'&&e1<='Z')){printf("魔王语言错误！\n");mark=0;break;}}if(mark==1&&f==1){ClearStack(S);InStack(MoWang,S);while(!StackEmpty(S)){//栈不空时Pop(S,e1);if(e1=='B'){Push(temp,e1);}else if(e1=='A'){Push(temp,e1);}else if(e1=='('){//用队存储括号中的元素Push(temp,flag);//有括号的话就用flag标记Pop(S,e1);while(e1!=')'){EnQueue(Q,e1);Pop(S,e1);}if(!QueueEmpty(Q)){DeQueue(Q,key);}}else{Push(temp,e1);f=0;}}while(!StackEmpty(temp)){//边处理边进栈Pop(temp,e1);if(e1!=flag){//把括号外的元素压入中Push(S,e1);}else{while(!QueueEmpty(Q)){//处理括号中的元素进栈DeQueue(Q,e2);Push(S,key);Push(S,e2);}if(f!=0){//最后还要压一个keyPush(S,key);}}}printf("解释后的语言为：\n");while(!StackEmpty(S)){//依次出栈输出处理后的元素Pop(S,e);EnQueue(Q,e);//元素进队是为了输出对应汉字if(e=='B'){printf("%s",B);}else if(e=='A'){printf("%s",A);}else{printf("%c",e);}}printf("\n");while(!QueueEmpty(Q)){//输出对应汉字DeQueue(Q,e);switch(e){case 't': printf("天");break;case 'd' : printf("地"); break;case 's' : printf("上"); break;case 'a' : printf("一只"); break;case 'e' : printf("鹅"); break;case 'z' : printf("追"); break;case 'g' : printf("赶"); break;case 'x' : printf("下"); break;case 'n' : printf("蛋"); break;case 'h' : printf("恨"); break;case 'B' : printf("天上一只鹅地上一只鹅");break;case 'A' : printf("上一只鹅");break;default : printf("*");break;}}printf("\n");}system("pause");return 0;}[读者手册]1、本程序的运行环境为dos操作系统，执行文件为“魔王解释语言.exe”。
数据结构魔王语言实验报告
数据结构与算法实验报告姓名院系学号任课教师指导教师实验地点软件学院实验时间2011年10月29 日实验名称数据结构实验一栈和队列同组人无预习报告(对实验主要内容的认识) 得分实验内容（问题，思路，程序，结果）得分1.题目：魔王语言2.问题描述：有一个魔王总是使用自己的一种非常精练而抽象的语言讲话，没有人能听得懂,但他的语言是可以逐步解释成人能听懂的语言，因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的；α→β1β2…βm(θδ1δ2…δn)→δnθδn-1θ…δ2θδ1在这两种形式中，从左到右均表示解释。
试写一个魔王语言的解释系统，把他的话解释成人能听得懂得话。
3.算法思想描述（1）算法的思想①我将设置三个堆栈和两个队列处理这个问题，首先将魔王语言自右向左压入堆栈*2(一个用来测试S_3另一个用来操作S_1)，然后判断此句话中是否有括号，若无则直接将操作堆栈弹出到队列中然后输出；②若有括号则先弹出操作堆栈S_1到队列Q_1中,遇到"("时跳过这个括号然后将括号后面的第一个字母标记（记作A ），将除第一个字母外的其他字母弹出到队列Q_2中，直到遇到")"为止，将“）”弹出；③将Q_2的元素每后面一个加原来的第一个元素A 压入堆栈S_2;④将堆栈S_2的元素弹出到Q_1中，然后将S_1中剩余的元素弹出到Q_!; ⑤按照对应的字母翻译即可。
（2）算法流程图开始 是否有括号 直接将堆栈中的弹出入队列翻译输出 将魔王语言自右向左压入堆栈S_1 NO YES 将堆栈S_1中的元素弹出到Q_1 弹出元素为"(" YES NO 弹出（后第一个元素记为A 将剩余元素弹入队列Q_2中 NO弹出元素为）YES将Q_2元素每个加A压入栈S_2将S_2中的元素弹出到Q_1中将S_1中剩余元素弹出到Q_1中翻译后输出结果结束4.数据结构描述（描述解决问题用到的数据结构）（1）所用数据结构的描述S_1堆栈负责自右向左存放魔王语言S_2堆栈存放处理过的括号里的语言S_3堆栈负责判断是否有括号Q_1队列存放处理后的语言Q_2队列负责存放括号中的语言（2）函数功能说明及函数的实现源代码①堆栈实现#ifndef STACK_H_INCLUDED#define STACK_H_INCLUDED#include<stdio.h>#include<math.h>#include<stdlib.h>#include<string.h>#define MAXSIZE 100#define STACK_INIT_MAX 100#define STACKINCREMENT 10#define ERROR 0#define OK 1#define FALSE 0#define TRUE 1typedef int Status;typedef struct{ //顺序栈类型定义char *top;char *base;int stacksize;}SqStack;Status InitStack(SqStack &s){ //构造一个空栈ss.base=(char *)malloc(STACK_INIT_MAX*sizeof(char)); if(!s.base) exit(OVERFLOW); //存储分配失败s.top = s.base;s.stacksize = STACK_INIT_MAX;return OK;}Status Pop(SqStack &s,char &e){ //删除s的栈顶元素，并以e返回其值if(s.top == s.base) return FALSE;s.top--;e = *(s.top);return TRUE;}Status Push(SqStack &s,char e){ //在栈s的栈顶插入新的栈顶元素e if((s.top-s.base) >= s.stacksize){s.base=(char*)realloc(s.base,(s.stacksize+STACKINCREMENT) * sizeof(char));if(!s.base) exit(OVERFLOW); //存储分配失败s.top = s.base + s.stacksize;s.stacksize += STACKINCREMENT;}*s.top = e;s.top++;return OK;}Status DestroyStack(SqStack &s){ //销毁栈sfree(s.base);s.stacksize = 0;return OK;}void InStack(char* ch,SqStack &s){//把字符数组从右至左压入栈中int i,L=0;while(ch[L]!='\0'){L++;}for(i=L-1;i>=0;i--){Push(s,ch[i]);}}Status StackEmpty(SqStack s){//栈是否为空if(s.top==s.base){return 1;}else{return 0;}}#endif // STACK_H_INCLUDED②队列实现#ifndef QUEUE_H_INCLUDED #define QUEUE_H_INCLUDED #include<stdio.h>#include<math.h>#include<stdlib.h>#include<string.h>#define MAXSIZE 100#define ERROR 0#define OK 1#define FALSE 0#define TRUE 1typedef struct{ //循环队列类型定义char *base;int front;int rear;}SqQueue;Status InitQueue(SqQueue &q){ //构造一个空队列qq.base = (char *)malloc(MAXSIZE*sizeof(char));if(!q.base) exit(OVERFLOW); //存储分配失败q.front = q.rear = 0;return OK;}Status EnQueue(SqQueue &q,char e){ //插入元素e为q的新的队尾元素if((q.rear+1) % MAXSIZE == q.front) return ERROR;q.base[q.rear] = e;q.rear = (q.rear + 1) % MAXSIZE;return OK;}Status DeQueue(SqQueue &q,char &e){ //若队列不空，则删除q的对头元素，用e返回其值，//并返回OK；否则返回ERRORif(q.front == q.rear) return ERROR;e = q.base[q.front];q.front = (q.front + 1) % MAXSIZE;return OK;}Status DestroyQueue(SqQueue &q){ //销毁队列q，q不再存在free(q.base);return OK;}#endif // QUEUE_H_INCLUDED③main函数实现#include <iostream>#include"Stack.h"#include"Queue.h"int main(){int length,i,mark; //length表示魔王语言的长度，mark为"("数mark=0;char e,str,j; //e为插入值或删除值，str为重复打印的字符，j为检测符char MoWang[100];//用来储存魔王的语言SqStack S_1;SqStack S_2;SqStack S_3;//检测栈InitStack(S_1);//初始化堆栈InitStack(S_2);InitStack(S_3);SqQueue Q_1;SqQueue Q_2;InitQueue(Q_1);//初始化队列InitQueue(Q_2);printf("请输入魔王的语言:\n");scanf("%s",&MoWang);//将魔王语言存入数组中length=strlen(MoWang);//魔王语言的长度包括括号i=0;InStack(MoWang,S_1);//将魔王语言自右向左入栈InStack(MoWang,S_3);//检测魔王语言while(!StackEmpty(S_3)){Pop(S_3,j);if(j=='('){mark=1;}}if(mark==1){while(e!=')'){//处理")"之前的元素Pop(S_1,e);if(e=='('){Pop(S_1,str);//记录需要重复打印的字符while(e!=')'){Pop(S_1,e);EnQueue(Q_2,e);//将括号内的元素入队列i++;}break;}EnQueue(Q_1,e);//将"("外的元素存入第一个队列中}for(;i>2;i--)//将括号内除了第一个和最后一个元素，其他元素连同第一个元素分次入栈{DeQueue(Q_2,e);//将队列中的第一个元素弹出存入ePush(S_2,e);//将e压入s_2中Push(S_2,str);//将str压入s_2中}DeQueue(Q_2,e);//将括号中的最后一个元素弹出存入ePush(S_2,e);//将e压入s_2中//将s_2堆栈中的元素弹出到队列Q_1中while(!StackEmpty(S_2)){Pop(S_2,e);EnQueue(Q_1,e);}while(!StackEmpty(S_1))//将魔王语言")"后的读入到Q_1中{Pop(S_1,e);EnQueue(Q_1,e);}}else{//若无括号直接输入while(!StackEmpty(S_1)){Pop(S_1,e);EnQueue(Q_1,e);}}while(Q_1.front!=Q_1.rear){DeQueue(Q_1,e); //删除队首元素switch(e) //判断并打印翻译后的语言{case 't': printf("天");break;case 'd': printf("地");break;case 's': printf("上");break;case 'a': printf("一只");break;case 'w': printf(",");break;case 'e': printf("鹅");break;case 'z': printf("追");break;case 'g': printf("赶");break;case 'x': printf("下");break;case 'n': printf("蛋");break;case 'i': printf("恨");break;case 'A': printf("上一只鹅");break;case 'B': printf("天上一只鹅地上一只鹅");break;default: printf("error!!!");}}printf("\n"); //换行DestroyQueue(Q_1);DestroyQueue(Q_2); //释放队列qDestroyStack(S_1); //释放栈s DestroyStack(S_2);return 0;}5.测试结果翻译成功结果如下图：实验结论得分成功利用堆栈和数组完成魔王语言的翻译教师评价总分实际得分。
魔王语言解释
一．实验目的设计中要求综合运用所学知识，上机解决一些与实际应用结合紧密的、规模较大的问题。
通过分析、设计、编码、调试等各环节的训练，使学生深刻理解、牢固掌握数据结构和算法设计技术，掌握分析、解决实际问题的能力。
通过这次设计，要求在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面，加深对课程基本内容的理解。
同时，在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练二．实验内容主要功能：魔王总是使用自己的一种非常精练而抽象的语言讲话,没人能听懂,但他的语言是可逐步解释成人能听懂的语言,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:1)a---> (B1)(B2)....(Bm)2)[(op1)(p2)...(pn)]---->[o(pn)][o(p(n-1))].....[o(p1)o]在这两种形式中,从左到右均表示解释.试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话.基本要求:用下述两条具体规则和上述规则形式(2)实现.设大写字母表示魔王语言的词汇;小写字母表示人的语言的词汇;希腊字母表示可以用大写字母或小写字母代换的变量.魔王语言可含人的词汇.1) B --> tAdA2) A --> sa三．实验步骤（可选）声明：#include<iostream>using namespace std;#include<string>#define STACK_INIT_SIZE 100#define STACKINCREMENT 10void EnQueue(struct LinkQueue &q,char e) //元素入队列void DeQueue(LinkQueue &q,char &e) //元素出队列int QueueEmpty(struct LinkQueue q) //判断栈是否为空void InStack(char *ch,stack &s) //把字符压入栈中void InQueue(char *ch, LinkQueue &q) //数组元素入队列void ClearQueue(LinkQueue &q, char e) //清空队列定义结构体：struct stack //栈结构体定义{char* base;char* top;int stacksize;};struct LinkQueue //队列结构体定义{struct Queue* front;struct Queue* rear;};初始化栈void InitStack(stack &s){s.base=(char*)malloc(STACK_INIT_SIZE*sizeof(char));if(!s.base)exit(-1);s.top=s.base;s.stacksize=STACK_INIT_SIZE;}程序主函数：void main(){int i=0,h;char a[100];char A[]="sae";char B[]="tsaedsae";int mark=1;struct stack S;InitStack(S);LinkQueue Q,Q1;InitQueue(Q);InitQueue(Q1);char mowang[100];char x,e;cout<<" *********************魔王语言********************"<<endl<<endl;cout<<" 请输入你要翻译的魔王语言";gets(mowang); //获取字符串存入mowang数组中InStack(mowang,S); //把要解释的魔王语言压入栈中(从右至左)cout<<endl<<" 魔王语言翻译为人语言为:";while(!StackEmpty(S)){Pop(S,e);if(e=='('){mark=0;if(StackEmpty(S)){cout<<" 你输入的魔王语言不合法"<<endl;ClearQueue(Q1,e);break;}Pop(S,e);while(mark==0){if(e!=')')EnQueue(Q,e); //将括号内的字符存入队列else{mark=1;break;}if(!StackEmpty(S))Pop(S,e);elsebreak;}if(mark==0){cout<<" 你输入的魔王语言不合法"<<endl;ClearQueue(Q1,e);break;}if(!QueueEmpty(Q)){DeQueue(Q,e); //规则2字符进栈x=e;Push(S,x);while(!QueueEmpty(Q)){DeQueue(Q,e);Push(S,e);Push(S,x);}}e='\0';}if((e!='\0' && e<'A') || (e>'Z' && e<'a') || (e>'z')) {cout<<" 你输入的魔王语言不合法";ClearQueue(Q1,e);break;}if(e){switch(e){case 'B' : cout<<B; InQueue(B,Q1); e='\0';break;case 'A' :cout<<A;InQueue(A,Q1); e='\0'; break;default : cout<<e;}}if(e)EnQueue(Q1,e);}cout<<endl<<endl<<" 与汉字建立关系输出为："<<endl; cout<<" ";while(!QueueEmpty(Q1)){DeQueue(Q1,e);switch(e){case 't' : cout<<"天";break;case 'd' : cout<<"地"; break;case 's' : cout<<"上"; break;case 'a' : cout<<"一只"; break;case 'e' : cout<<"鹅"; break;case 'z' : cout<<"追"; break;case 'g' : cout<<"赶"; break;case 'x' : cout<<"下"; break;case 'n' : cout<<"蛋"; break;case 'h' : cout<<"恨"; break;case '\0': cout<<""; break;}}cout<<endl;}四．实验的结果及分析。
魔王语言实验报告材料
数据结构实验报告（魔王语言）一、【实验构思（Conceive）】(10%)（本部分应包括：描述实验实现的基本思路，包括所用到的离散数学、工程数学、程序设计、算法等相关知识）魔王语言的解释规则：大写字母表示魔王语言的词汇，小写字母表示人的词汇语言,魔王语言中可以包含括号，魔王语言的产生式规则在程序中给定，当接收用户输入的合法的魔王语言时，通过调用魔王语言翻译函数来实现翻译。
二、【实验设计(Design)】(20%)（本部分应包括：抽象数据类型的功能规格说明、主程序模块、各子程序模块的伪码说明，主程序模块与各子程序模块间的调用关系）抽象数据类型：typedef struct{StackElementType elem[Stack_Size];int top;}SeqStack;主程序模块：int main(){GhostLanage();printf("\n\t按任意键退出\n\n");}各子程序模块：/*初始化栈*/void InitStack(SeqStack *s){s->top=-1;}/*进栈操作*/void Push(SeqStack *s,StackElementType x){if(s->top==Stack_Size-1)printf("\n\t栈已满！ ");else {s->top++;s->elem[s->top]=x;}}/*出栈操作*/void Pop(SeqStack *s,StackElementType *x){if(s->top==-1)printf("\n\t栈为空！ ");else {*x=s->elem[s->top];s->top--;}}/*取栈顶元素*/void GetTop(SeqStack *s,StackElementType *x){if(s->top==-1)printf("\n\t栈为空！ ");else *x=s->elem[s->top];}/*判断栈是否为空*/int IsEmpty(SeqStack *s){if(s->top==-1) return(0);else return(1);}/*魔王语言翻译函数*/void GhostLanage(){SeqStack B,A,s,B1,A1,r,M;StackElementType ch,ch1,ch2,x;char aa[100];int choice,i=0,n;InitStack(&B);InitStack(&A);InitStack(&s);InitStack(&r) ;InitStack(&M);printf("魔王语言的转换形式： B->tAdA A->sae");Push(&B,'t');Push(&B,'A');Push(&B,'d');Push(&B,'A');Push(&A,'s');Push(&A,'a');Push(&A,'e');printf("\n请输入要翻译的魔王语言:\n");scanf("%s",aa);for(i=0;aa[i]!='\0';i++)Push(&s,aa[i]);while(IsEmpty(&s)){Pop(&s,&ch);if(ch=='B'){B1=B;while(IsEmpty(&B1)){Pop(&B1,&ch1);if(ch1=='A'){A1=A;while(IsEmpty(&A1)) {Pop(&A1,&ch2); Push(&r,ch2); }}else Push(&r,ch1);}}else if(ch=='A'){A1=A;while(IsEmpty(&A1)) {Pop(&A1,&ch2); Push(&r,ch2); }}else if(ch==')'){Pop(&s,&ch2);while(ch2!='('){Push(&M,ch2);Pop(&s,&ch2);}GetTop(&M,&ch2);x=ch2;Pop(&M,&ch2);while(IsEmpty(&M)){Push(&r,x);Pop(&M,&ch2);Push(&r,ch2);}Push(&r,x);}else Push(&r,ch);}M=r;printf("\n\n\t翻译的结果为： ");while(IsEmpty(&M)){Pop(&M,&ch);printf("%c",ch);}printf("\n\n\t是否继续翻译为汉语：（ 1-继续，0-不继续）"); scanf("%d",&n);if(n==1){ printf("\n\n\t翻译为汉语的结果为： \n\n\t");M=r;while(IsEmpty(&M)){Pop(&M,&ch);if(ch=='t') printf("天");else if(ch=='d') printf("地");else if(ch=='s') printf("上");else if(ch=='a') printf("一只");else if(ch=='e') printf("鹅");else if(ch=='z') printf("追");else if(ch=='g') printf("赶");else if(ch=='x') printf("下");else if(ch=='n') printf("蛋");else if(ch=='h') printf("恨");}printf("\n");}else ;}三、【实现描述（Implement）】(30%)（本部分应包括：抽象数据类型具体实现的函数原型说明、关键操作实现的伪码算法、函数设计、函数间的调用关系，关键的程序流程图等，给出关键算法的时间复杂度分析。
魔王语言报告(带有完整程序)
郵電學院数据结构课程设计报告题目：魔王语言院系名称：专业名称：班级：学生：学号（8位）：指导教师：设计起止时间：一. 设计目的以栈和队列为数据结构，使用文件读写、查找等操作，完成对魔王语言的解释。
二. 设计容有一个魔王总是使用自己的一种非常精炼而抽象的语言讲话，没有人能听懂。
但他的语言是可以逐步解释成人能懂的语言的，因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的：(1)α→β1β2 ……βm(2)(θδ1δ2 ……δn)→θδnθδn-1 …… θδ1 θ在这两种形式中，从左到右均表示解释；从右到左均表示抽象。
试写一个魔王语言的解释系统，把他的话解释成人能听得懂的话。
三．概要设计通过栈、队列和函数的调用来实现魔王语言。
12．各个模块详细的功能描述。
1.通过打开规则文件读取文件中的数据，并将其保存在数组r 中2.通过打开小写字母匹配文件读取文件中的数据，并将其存储在链表head 中。
3.通过这个函数将所有的魔王语言存储在栈中。
4.通过这个函数将魔王语言中所有的括号去掉，并将其结果存储在队列Q 中5.通过这个函数，根据规则文件，将去掉括号后的魔王语言中的大写字母全部转换为小写字母 6通过这个函数，根据小写字母匹配文件，将小写字母全部翻译为人类语言。
7.通过这个文件将翻译好的魔王语言保存在结果文件中，并为文件加密。
四．详细设计1．功能函数的调用关系图1.Open-rule()、Open-mean()keep()和translate()函数无调用其他自己设定的函数； 2．Pushall()函数调用关系图3. Test_brack( );函数调用关系图4．dealUpletter();函数调用关系图5. password( );函数的调用关系图2．各功能函数的数据流程图dealUpletter函数的流程图：brack()函数的流程图：brack()函数中的for循环语句：forfor循环语句中的while语句2的流程图:for循环语句中的if语句的流程图:3．重点设计及编码void brack(LinkStack top,LinkQueue * Q)//处理括号{int n,k,s,i;LinkStackNode * p;LinkStack top1;char x,y,ch;n=0;for(p=top->next;p!=NULL;p=p->next)if(p->data == '(')n++; //记录括号的个数for(i=1;i<=n;i++){for(s=0;s<n-i+1;){Pop(top,&x); //将最层括号外的数据存在下层栈if(x == '(')s++;if(s!=n-i+1)EnterQueue(Q,x);}InitStack(&top1);k=0;while(top->next->data != ')' ) //将最层的括号的字母逆序存储在辅助栈{Pop(top,&x);if(k==0)ch=x; //记录最层括号第一个字母Push(top1,x);k++;}Pop(top,&y); //最层括号）出栈k=0; //处理最层括号的容Pop(top1,&y);while(top1->next != NULL){if(k%2 == 0)EnterQueue(Q,ch); //把最层的括号的容插入队列中if(k%2 == 1){EnterQueue(Q,y);Pop(top1,&y);}k++;}EnterQueue(Q,ch);while(top->next!=NULL){Pop(top,&x);EnterQueue(Q,x); //将最层括号）外的字母存到队列中}if(i!=n){InitStack(&top);while(Q->front->next != NULL){ch = Q->front->next->data;DeleteQueue(Q,&ch); //处理外层括号，将队列中的数据存储在栈中Push(top1,ch); //按照队列的存储数据存储到栈top中，top为辅助栈}while(top1->next!=NULL){Pop(top1,&ch);Push(top,ch);}InitQueue(Q); //最后的结果存储在队列中}}}void dealUpletter(LinkQueue * Q,struct rule *r,LinkQueue* Q1) //处理大写字母{LinkQueueNode * q;char ch;int flage;InitQueue(Q1);while(Q->front->next != NULL){DeleteQueue(Q,&ch);if(ch<='Z' && ch>='A')alter(ch,r,Q,Q1);elseEnterQueue(Q1,ch);}flage = 0;for(q=Q1->front->next;q!=NULL;q=q->next) //查询是否含有大写字母if(q->data>='A' && q->data <= 'Z')flage = 1;if(flage == 1){while(Q1->front->next != NULL){DeleteQueue(Q1,&ch);EnterQueue(Q,ch);}dealUpletter(Q,r,Q1);}}五．测试数据及运行结果1．正常测试数据和运行结果1．魔王说的话B(ehnxgz)B解释成人类语言：tsaedsaeezegexenehetsaedsae将魔王语言翻译成汉语:天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅2. 魔王说的话A（hnxB(egz)xh）解释成人类语言：saehhhxhehghehzhehtsaedsaehxhnh将魔王语言翻译成汉语:上一只鹅恨恨恨下恨鹅恨赶恨鹅恨追恨鹅恨天上一只鹅地上一只鹅恨下恨蛋恨3. 魔王说的话se（heasan）d解释成人类语言：sehnhahshahehd将魔王语言翻译成汉语:上鹅恨蛋恨一只恨上恨一只恨鹅恨地异常测试数据及运行结果1、输入：魔王说的话（）输出：解释成人类语言将魔王语言翻译成汉语2、输入：输入：魔王说的话se输出：解释成人类语言se将魔王语言翻译成汉上鹅六．调试情况，设计技巧及体会语:1．改进方案此次魔王语言的设计，合理之处：使用链式存储结构，位置确定，可以简化思维过程。
魔王语言数据结构实验报告课案
数据结构实验报告2.2 魔王语言解释[问题描述]有一个魔王总是使用自己的一种非常精练而又抽象的语言讲话，没有人能听得懂，但他的语言是可以逐步解释成人能听懂的语言，因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的：（1）α－> β1β2…βm（2）（θδ1δ2…δn)－>θδnθδn－1…θδ1θ在这两种形式中，从左到右均表示解释。
试写一个魔王语言的解释系统，把他的话解释成人能听得懂的话。
[基本要求]用下述两条具体规则和上述规则形式（2）实现。
设大写字母表示魔王语言的词汇；小写字母表示人的语言词汇；希腊字母表示可以用大写字母或小写字母代换的变量。
魔王语言可含人的词汇。
（1）B －> tAdA （2）A －> sae[测试数据]B(ehnxgz)B解释成tsaedsaeezegexenehetsaedsae若将小写字母与汉字建立下表所示的对应关系，则魔王说的话是：“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。
t d s a e z g x n h 天地上一只鹅追赶下蛋恨一：需求分析(1)以一维数组demon[ i ]表示魔王语言．(2)魔王语言由用户输入,初始保存在demon[ i ]中． (3)魔王语言与人类语言对应关系固化在程序中． (4)实现过程：A：初始，魔王语言接收后存放在demon[ i ]中．B：初次遍历数组，将数组中括号内的元素入栈，同时插入相应首字母；C：再次遍历数组，将数组元素依次入队。
（小写字母直接入队；大写字母经翻译成相应字符后入队；遇到括号，将栈中保存的元素依次出栈入队）在翻译过程中，如果依旧包含大写字母，则置flag为1，否则为0。
D：将队列中元素赋值给demon[ i ]。
如果此时flag=1，则再次重复C过程。
直至所有元素为人类语言。
E：输出demon[ i ]。
此时数组中元素为对应的人类语言。
注：如果程序中没有相应的对应关系，则翻译成“???”。
魔王语言实习报告
数据结构实验报告栈和队列及其应用题目：魔王语言的解释物联网1班陈世超 14051411 2015-11-23一．需求分析1 以栈保存魔王语言。
2.魔王语言由用户输入，保存在栈中3.魔王语言与人类语言对应转化二．概要设计为了实现上述操作，应以栈和队列为主。
1．基本操作：IntStack(&s )操作结果：构造空栈sPush(&s,e)在栈s的栈顶插入新元素ePop(&s,e)删除s的栈顶元素，并以e返回其值。
2．本程序包含三个模块：（1）主程序模块；（2）构造栈和队列的各种操作；（3）输出人类语言；三．详细设计1．元素类型，结点类型和指针类型：class Stack{public:char *base;char *top;int stacksize;};class Node{public:char date;class Node*next;};class Queue{public:class Node *front,*rear;};2．每个模块的分析：创建栈，队列，队列节点，队列和栈的操作：void Intstack(Stack &s)//构造空栈{s.base=new char[MAXSIZE];if(!s.base){cout<<"创建栈失败"<<endl;return;}s.top=s.base;s.stacksize=MAXSIZE;return;}void push(Stack &s,char e)//将元素e压入栈，top指向栈顶的下一个空白地方{if(s.top-s.base>=s.stacksize){s.base=new char[MAXSIZE*sizeof(char)];char* temp =new char(s.stacksize+MAXSIZE);memmove(temp,s.base,MAXSIZE*sizeof(char));delete []s.base;s.base=temp;if(!s.base){cout<<"构栈失败"<<endl;return;}s.top=s.base+s.stacksize;s.stacksize+=MAXSIZE;}*s.top++=e;}int pop(Stack &s,char &e)//将栈顶的元素赋给e,并且top指向这一个元素{if(s.top==s.base) //栈为空{return -1;}e=*--s.top;return 1;}void Intqueue(Queue &q)//构建空队列{q.front=q.rear=new Node;if(!q.front){cout<<"构队列失败"<<endl;return;}q.front->next=NULL;}void Intqueue(Queue &q,char e)//将元素e放到一个新节点里面，将节点压入队列{struct Node *p;p=new Node;p->date=e;p->next=NULL;q.rear->next=p;q.rear=p;}int Popqueue(Queue &q,char &e)//将队列的第一个元素返回给e，然后删除（front指向第一个元素前的空白部分,rear指向最后一个元素){Node *p;if(q.front==q.rear){return -1;}p=q.front->next;e=p->date;q.front->next=p->next;if(q.rear==p)q.rear=q.front;delete []p;return 1;}从魔王语言右边开始数；for(i=strlen(str)-1;i>=0;i--) //从魔王语言右边开始数{if(str[i]=='(') //输入的元素如果为坐括号{pop(s,e1); //e1为栈顶元素（即为括号内第一个元素)pop(s,e);while(e!=')') //将括号内的全部放入队列里面{Intqueue(q,e); //将元素e加入队列q中pop(s,e); //e元素指向栈的前一个元素}while(Popqueue(q,e)!=-1)//队列不为空{push(s,e1); //将括号内第一个元素压入栈push(s,e); //将从括号内最后一个元素开始往左压入栈}push(s,e1); //最后再将括号内的第一个元素压入栈}elsepush(s,str[i]); //从右往左把B到'（'前的部分压入栈}完整的程序：#include<iostream>#include<string>using namespace std;const int MAXSIZE=100;class Stack{public:char *base;char *top;int stacksize;};class Node{public:char date;class Node*next;};class Queue{public:class Node *front,*rear;};void Intstack(Stack &s)//构造空栈{s.base=new char[MAXSIZE];if(!s.base){cout<<"创建栈失败"<<endl;return;}s.top=s.base;s.stacksize=MAXSIZE;return;}void push(Stack &s,char e)//将元素e压入栈，top指向栈顶的下一个空白地方{if(s.top-s.base>=s.stacksize){s.base=new char[MAXSIZE*sizeof(char)];char* temp =new char(s.stacksize+MAXSIZE);memmove(temp,s.base,MAXSIZE*sizeof(char));delete []s.base;s.base=temp;if(!s.base){cout<<"构栈失败"<<endl;return;}s.top=s.base+s.stacksize;s.stacksize+=MAXSIZE;}*s.top++=e;}int pop(Stack &s,char &e)//将栈顶的元素赋给e,并且top指向这一个元素{if(s.top==s.base) //栈为空{return -1;}e=*--s.top;return 1;}void Intqueue(Queue &q)//构建空队列{q.front=q.rear=new Node;if(!q.front){cout<<"构队列失败"<<endl;return;}q.front->next=NULL;}void Intqueue(Queue &q,char e)//将元素e放到一个新节点里面，将节点压入队列{struct Node *p;p=new Node;p->date=e;p->next=NULL;q.rear->next=p;q.rear=p;}int Popqueue(Queue &q,char &e)//将队列的第一个元素返回给e，然后删除（front指向第一个元素前的空白部分,rear指向最后一个元素){Node *p;if(q.front==q.rear){return -1;}p=q.front->next;e=p->date;q.front->next=p->next;if(q.rear==p)q.rear=q.front;delete []p;return 1;}int main(){cout<<"输入魔王语言(100以内)"<<endl;char str[500];cin>>str; //输入魔王语言char e,e1;int i;Stack s;Queue q;int n=0;Intstack(s); //建立空栈Intqueue(q); //建立空队列for(i=strlen(str)-1;i>=0;i--) //从魔王语言右边开始数{if(str[i]=='(') //输入的元素如果为坐括号{pop(s,e1); //e1为栈顶元素（即为括号内第一个元素)pop(s,e);while(e!=')') //将括号内的全部放入队列里面{Intqueue(q,e); //将元素e加入队列q中pop(s,e); //e元素指向栈的前一个元素}while(Popqueue(q,e)!=-1)//队列不为空{push(s,e1); //将括号内第一个元素压入栈push(s,e); //将从括号内最后一个元素开始往左压入栈}push(s,e1); //最后再将括号内的第一个元素压入栈}elsepush(s,str[i]); //从右往左把B到'（'前的部分压入栈}while(pop(s,e)!=-1) //栈不为空{switch(e){case 't':cout<<"天";break;case 'd':cout<<"地";break;case 's':cout<<"上";break;case 'a':cout<<"一只";break;case 'e':cout<<"鹅";break;case 'z':cout<<"追";break;case 'g':cout<<"赶";break;case 'x':cout<<"下";break;case 'n':cout<<"蛋";break;case 'h':cout<<"恨";break;case 'A':cout<<"上一只鹅";break;case 'B':cout<<"天上一只鹅地上一只鹅";break;}}return 0;}四．调试结果及说明1．说明（1）本程序的运行环境为C-FREE 5.0。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构实验报告2.2 魔王语言解释[问题描述]有一个魔王总是使用自己的一种非常精练而又抽象的语言讲话，没有人能听得懂，但他的语言是可以逐步解释成人能听懂的语言，因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的：（1）α－> β1β2…βm（2）（θδ1δ2…δn)－>θδnθδn－1…θδ1θ在这两种形式中，从左到右均表示解释。
试写一个魔王语言的解释系统，把他的话解释成人能听得懂的话。
[基本要求]用下述两条具体规则和上述规则形式（2）实现。
设大写字母表示魔王语言的词汇；小写字母表示人的语言词汇；希腊字母表示可以用大写字母或小写字母代换的变量。
魔王语言可含人的词汇。
（1）B －> tAdA （2）A －> sae[测试数据]B(ehnxgz)B解释成tsaedsaeezegexenehetsaedsae若将小写字母与汉字建立下表所示的对应关系，则魔王说的话是：“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。
t d s a e z g x n h 天地上一只鹅追赶下蛋恨一：需求分析(1)以一维数组demon[ i ]表示魔王语言．(2)魔王语言由用户输入,初始保存在demon[ i ]中． (3)魔王语言与人类语言对应关系固化在程序中． (4)实现过程：A：初始，魔王语言接收后存放在demon[ i ]中．B：初次遍历数组，将数组中括号内的元素入栈，同时插入相应首字母；C：再次遍历数组，将数组元素依次入队。
（小写字母直接入队；大写字母经翻译成相应字符后入队；遇到括号，将栈中保存的元素依次出栈入队）在翻译过程中，如果依旧包含大写字母，则置flag为1，否则为0。
D：将队列中元素赋值给demon[ i ]。
如果此时flag=1，则再次重复C过程。
直至所有元素为人类语言。
E：输出demon[ i ]。
此时数组中元素为对应的人类语言。
注：如果程序中没有相应的对应关系，则翻译成“???”。
二：概要设计：1：设定栈的抽象数据类型定义：ADT stack｛数据对象：D＝｛ai|ai∈CharSet,i＝1,2,…,n,n>=0｝数据关系：R1＝{<ai-1,ai>|ai-1,ai∈D,i＝2,…,n} 基本操作：initstack (＆s)操作结果:构造一个空栈s. push (＆s,e)初始条件:栈s已存在.操作结果:在栈s的栈顶插入新的栈顶元素e. pop(＆s,＆e)初始条件:栈s已存在.操作结果:删除s的栈顶元素,并以e返回其值. }ADT stack2:设定队列的抽象数据类型:ADT queue{数据对象：D＝｛ai|ai∈Elemset,i＝1,2,…,n,n>=0｝数据关系：R1＝{<ai-1,ai>|ai-1,ai∈D,i＝2,…,n} 基本操作：initqueue(&q)操作结果: 构造一个空队列q.enqueue(&q, e)初始条件: 队列q已存在.操作结果: 插入元素e为q的新队尾元素.dequeue(&q,&e)初始条件: q为非空队列.操作结果: 删除q的队头元素,并用e返回其值. }ADT queue3:本程序包含四个模块:1)主函数模块.其中主函数为:status main() {初始化栈; 初始化队列;接收魔王语言输入到数组demon[i ]; 遍历数组将括号中元素进栈;while(数组demon[i ]中元素有大写字母) { 翻译排序处理后入队列;将对列元素保存在数组demon[i ]; } 输出人类语言(数组demon[ i]); }2)括号内元素入栈处理模块. tempstack(&temps)将括号内元素入栈,依次插入首字符. 举例：(abcd)－>adacaba.3)排序入队列模块. sort(&s,&q) {遍历数组; {遇到小写字母,直接入队列;遇到大写字母,翻译大写后入队列;遇到括号,将栈中保存的元素依次出栈入队列; } }4)翻译大写处理模块. spenqueue(&*q,key) {switch(key) {找到各个大写字母对应的字符串. 没有相应的则解释为’???’} }各模块之间调用关系: 主函数模块{括号内元素入栈处理模块; 排序入队模块{翻译大写处理模块; } }三:详细设计1.定义全局变量#define TRUE 1 #define FALSE 0 #defineOK 1 #define ERROR 0 #define NULL 0 #define OVERFLOW -2 #define MAXSIZE100 #define stack_init_size 100 #define stackincrement 10typedef char selemtype; typedef char qelemtype; typedef char elemtype; typedef int status;char e;char demon[MAXSIZE];2.栈类型及其基本操作typedef struct {selemtype *base; selemtype *top; int stacksize; }sqstack;status initstack (sqstack *s) {s->base=(selemtype*)malloc(stack_init_size*sizeof(selemtype));if(!s->base) exit (OVERFLOW); s->top=s->base; s->stacksize=stack_init_size; return OK; }/*创建栈*/status push (sqstack *s,selemtype e) {if(s->top-s->base>=s->stacksize) {s->base=(elemtype *)realloc(s->base,(s->stacksize+stackincrement)*sizeo f(elemtype)); if(!s->base) exit(OVERFLOW); s->top=s->base+s->stacksize;s->stacksize+=stackincrement; }*(s->top++)=e; return OK; }/*入栈*/status pop(sqstack *s,selemtype *e) {if(s->top==s->base) return ERROR;*e=*(--(s->top)); return OK; }/*出栈*/3.队列类型及其基本操作typedef struct qnode {qelemtype data; struct qnode*next; }qnode,*queueptr; typedef struct {queueptr front; queueptr rear; }linkqueue; status initqueue(linkqueue *q) {q->front=q->rear=(queueptr)malloc(sizeof(qnode)); if(!q->front) exit(OVERFLOW);q->front->next=NULL; return OK; }/*创建队列*/ status enqueue(linkqueue *q,qelemtype e) {queueptr p;p=(queueptr)malloc(sizeof(qnode)); if(!p)exit(OVERFLOW); p->data=e; p->next=NULL;q->rear->next=p; q->rear=p; return OK; }/*入队*/status dequeue(linkqueue *q,qelemtype *e) {queueptr p;if(q->front==q->rear) return ERROR;p=q->front->next; *e=p->data;q->front->next=p->next; if(q->rear==p) { q->rear=q->front; }free(p);return OK; }/*出队*/四:调试分析1. 函数调用比较多,因而得仔细对待数值和地址的传递.2. 由于魔王语言中’B’中仍然包含着大写字母(tAdA).所以考虑设置flag.3. 函数数组遍历.进栈出栈.入队出队中都要牵扯指针的移动,所以要仔细考虑一循环的条件以及进栈元素的个数. 五:用户手册1. 本程序运行环境为DOS/WINDOWS操作系统,执行文件为: 魔王语言解释.exe。
2. 进入程序即显示提示信息: WELCOME!*************************************** Please Input The Demon's Words: !: Less Than30 Letters: ) !: Please Stopped By '#': )*************************************** The Demon's Words:等待用户输入.用户输入字符以’#’回车结束.*************************************** The Human Words: （翻译后的语言）*************************************** THANK YOU!源程序（省略）测试结果。