魔王语言解释-数据结构课程设计

合集下载

数据结构-课程设计报告-魔王语言解释

数据结构-课程设计报告-魔王语言解释

题目:魔王语言解释[问题描述]有一个魔王总是使用自己的一种非常精练而抽象的语言讲话,没有人能听懂,但他的语言是可以逐步解释成人能听懂的语言,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(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");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”。

魔王语言解释-大数据结构课程设计

魔王语言解释-大数据结构课程设计

实习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.测试结果翻译成功结果如下图:实验结论得分成功利用堆栈和数组完成魔王语言的翻译教师评价总分实际得分。

魔王语言报告(带有完整程序)

魔王语言报告(带有完整程序)

西安郵電學院数据结构课程设计报告题目:魔王语言院系名称:专业名称:班级:学生姓名:学号(8位):指导教师:设计起止时间:1/ 12一. 设计目的以栈和队列为数据结构,使用文件读写、查找等操作,完成对魔王语言的解释。

二. 设计内容有一个魔王总是使用自己的一种非常精炼而抽象的语言讲话,没有人能听懂。

但他的语言是可以逐步解释成人能懂的语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α→β1β2 ……βm(2)(θδ1δ2 ……δn)→θδnθδn-1 …… θδ1 θ在这两种形式中,从左到右均表示解释;从右到左均表示抽象。

试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话。

三.概要设计通过栈、队列和函数的调用来实现魔王语言。

12.各个模块详细的功能描述。

1.通过打开规则文件读取文件中的数据,并将其保存在数组r 中通过打开小写字母匹配文件读取文件中的数据,并将其存储在链表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函数的流程图:dealUpletter()函数中的if语句brack()函数的流程图:brack()函数中的for循环语句:for循环语句中的while语句1的流程图:for循环语句中的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.改进方案此次魔王语言的设计,合理之处:使用链式存储结构,位置确定,可以简化思维过程。

课程设计--魔王语言解释

课程设计--魔王语言解释

魔王语言解释一目的通过课程设计,巩固和加深对线性表、栈、队列、字符串、树、图、查找、排序等理论知识的理解;掌握现实复杂问题的分析建模和解决方法(包括问题描述、系统分析、设计建模、代码实现、结果分析等);提高利用计算机分析解决综合性实际问题的基本能力。

二需求分析1、输入输出形式输入一个用于表示魔王语言的字符串,用数组存储,输入应该是含有大小写字母及括号的字符串;输出包括解释成表示认得语言词汇的小写字母和相对应的汉字。

2、程序功能写一个魔王语言的解释系统,把他的话解释成人能听懂的话容。

设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母表示可以用大写字母或小写字母代换的变量。

魔王语言可含人的词汇。

规则如下:θα1α2….αn)→θαnθαn-规则 1 (θ1…..θα1规则2 B→tAdA规则3 A→sae例如,将 B(ehnxgz)B 解释成tsaedsaeezegexenehetsaedsae若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是“B(鹅恨蛋下赶追)B”。

翻译输出为“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。

三概要设计1、数据类型定义及含义本程序中使用了栈和队列两种数据类型,其中使用s栈用于将魔王语言的所有元素压入,temp栈用于压入魔王语言中括号外面的元素,队列q用于放括号里面的元素。

2、主程序流程主程序先调用InitStack构造两个空栈S和Temp,接着调用InitQueue构造队列q,然后通过调用函数lhh完成魔王语言的翻译。

再通过询问方式询问用户是否继续进行操作。

3、各模块功能各模块功能如下:⑴main主函数;⑵InitStack构造空栈;⑶Push入栈;⑷Pop出栈;⑸StackEmpty判断栈是否为空;⑹ClearStack清空栈;⑺InitQueue构造一个队列;⑻EnQueue入队;⑼DeQueue出队;⑽QueueEmpty判断队列是否为空;⑾InStack将字符数组所有元素入栈;⑿check_MoWang检验魔王语言是否正确;⒀Translate翻译魔王语言;⒁lhh核心代码部分,处理括号里的元素以及调用其它函数翻译魔王语言。

魔王语言解释

魔王语言解释
基本操作:
initstack (&s)
操作结果:构造一个空栈s.
push (&s,e)
初始条件:栈s已存在.
操作结果:在栈s的栈顶插入新的栈顶元素e.
pop(&s,&e)
初始条件:栈s已存在.
操作结果:删除s的栈顶元素,并以e返回其值.
}ADT stack
2:设定队列的抽象数据类型:
ADT queue{
(2)A -> sae
[测试数据]
B(ehnxgz)B解释成tsaedsaeezegexenehetsaedsae
若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是:“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。
t d s a e z g x n h
天 地 上 一只 鹅 追 赶 下 蛋 恨
do
{
i++;
c=demon[i ];
push(temps,c)/*第一次循环将次字母入栈*/;
push(temps,t);/*再将首字母进栈*/
}
while(c!=')');/*直到括号中元素全部进栈*/
pop(temps,&t);/*将多余进栈的首字母t出栈*/
pop(temps,&t); /*将多余进栈的’)’出栈*/
default:strcpy(a,"???"); /*不能翻译的魔王语言以”???”输出*/
}
while(a[j]!='\0') /*如果数组还有字母*/
{
enqueue(q,a[j]);/*进队*/
j++;
}
}/*特殊入队*/
6.排序入队处理函数

魔王语言解释数据结构课程设计报告.doc

魔王语言解释数据结构课程设计报告.doc

魔王语言解释程序一、问题引入1.问题描述有一个魔王总是使用自已的一种非常精练而抽象的语言讲话,没有人能听得懂。

但他的语言是可以逐步解释成人能懂的语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α →β 1β 2⋯β m(2) ( θ β1β 2⋯βm)→ ( θβ m⋯β 2θ β 1θ )在这两种形式中,从左到右均表示解释。

写一个魔王解释程序,将魔王的话解释成人能听懂的话。

2.基本要求用下述两种规则和下述规则(2)实现。

设大写字母表示魔王语言的词汇,小写字母表示人的词汇,希腊字母表示可以用大写字母或小写字母代换的变量。

魔王语言可含人的词汇。

(1) B → tAdA(2) A → sae3.测试数据B(einxgz)B解释成tsaedsaeezegexeneietsaedsae“天上一只鹅地上一若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是:只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。

t d s a e z g x n h 天地上一只鹅追赶下蛋恨4.实现提示将魔王的语言自右至左进栈,总是处理栈顶字符。

若是开括号,则逐一出栈,将字母顺序入队列,直至闭括号出栈,并按规则要求逐一出队列在处理后入栈。

5.本程序采用的是顺序栈。

基本操作列表:(1)据括号的个数设一个标记。

记下括号的位置。

(2)根据标记来执行依次的操作。

(3)没有括号,直接进队,据翻译函数2 输出人的语言。

(4)有括号,分为括号内的和括号外的。

,根据括号的位置:括号外的从右到左入栈;括号内的从左到右入栈,并且依次插入括号内的第一个字符。

据翻译函数 2 出栈并且翻译。

二、需求分析1.本演示程序中,魔王语言限制在小写字母‘a’ - ‘z’之间,且必须限制在括号内以及大写字母 A 和 B。

且允许出现重复字符或非法字符,程序运用时自动过滤去,输出的运算结果中将不含重复字符和非法字符。

2.魔王语言遵守如下规则:(θ δ 1δ 2δ 3⋯δ n)θ δ nθδ n-1 ⋯θδ 1θB tAdA A sae3.演示程序以用户和计算机对话的形式进行,即在计算机终端中显示提示信息之后,有用户自行选择下一步命令,相应输入数据和运算结果在其后显示。

数据结构课程设计报告-魔王语言实验报告模板

数据结构课程设计报告-魔王语言实验报告模板

西安郵電學院数据结构课程设计报告题目:魔王语言院系名称:计算机学院专业名称:软件工程班级:学生姓名:学号(8位):指导教师:设计起止时间:一. 设计目的1、熟悉链表、队列、栈、排序、查找、文件等内容的的使用。

2、将数据结构的内容结合到一起使用。

3、熟悉掌握数据结构的内容。

4、了解递归与非递归的使用。

二. 设计内容以栈和队列为数据结构,使用文件读写、查找等操作,完成对魔王语言的解释。

三.概要设计1.功能模块图;开始主函数输入魔王说的话调用取括号函数读取文件rule.txt 读取文件mean.txt将栈中的元素存入数组中将魔王的话转化成小写字母将魔王语言翻译为汉语意思将结果保存到文件中结束2.各个模块详细的功能描述。

1.入栈操作函数int push(Stack *s,char x)讲传递过来的字符入栈;2.出栈操作char pop(Stack *s)将当前栈顶的字符出栈,并将其返回;3.入队操作函数int queue_in(Queue *p,char ch)将传递过来的ch中的字符入队;4.出队操作char queue_out(Queue *p)将当前队头的字符出队,并将其返回;5.去除魔王语言中括号模块void deletenode(Stack *s,Queue *r,char a[],int i)利用队栈的进栈出栈操作,入队出队操作,将魔王语言中的括号去除,使之成为一个字母的序列;6 .文件读取函数void read_file(),void word_file()通过文件函数,读取rule和mean文件,并将其输出到终端;7.将栈中的元素存入数组中void store(char a[],Stack *s)将栈中的元素按次序存入到数组中;8. 魔王语言转字母语言void change(char a[])将输入的魔王语言通过循环判断转换成字母语言;9 .将字母语言翻译为人类语言void translate(char a[],struct Word *h)将已经由魔王语言转换成的字母语言通过对照转换成人类语言10.文件保存函数void save_file(struct Word *h)将已经转换好的魔王语言保存到自定义路径。

魔王语言实验报告范文

魔王语言实验报告范文

魔王语言实验报告范文数据结构课程设计报告题目:系部名称:专业名称:班级:学号:学生姓名:指导教师:时间:魔王语言通信工程一、课程设计目的(1)熟练掌握C语言和数据结构的相关操作。

(2)综合应用C语言的知识和数据结构的知识,编写程序,并且对以前所学的知识进行复习。

(3)培养学生独立完成课程设计的能力。

二、课程设计内容1.用带头结点的动态单链表来存储多项式;在此基础上完成多项式乘法运算要求以动态链表为存储结构、使用到查找和排序等操作;在创建多项式的过程中,可以按指数的任意顺序输入,并且可在同一多项式中输入指数相同的多项;在进行乘法操作之前,输出参与操作的两个多项式。

要求输出的多项式按指数降序排列,同指数的多项合并,项数的正负号显示合理。

2.魔王语言有一个魔王总是使用自己的一种非常精炼而抽象的语言讲话,没有人能听懂。

但他的语言是可以逐步解释成人能懂的语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α→β1β2……βm(2)(θδ1δ2……δn)→θδnθδn-1……θδ1θ在这两种形式中,从左到右均表示解释;从右到左均表示抽象。

试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话。

",读取文件,并统计1.读取文本文件(rule.t某t),将具体规则的对应关系读入数组或链中2.读取文本文件(mean.t某t),将小写字母及其对应的含义读入数组或链表中",处理规则形式(2)按照规则形式(2)处理魔王所说的话。

处理完毕后,对应的解释语句不再含有()。

处理规则形式(1)按照读入的具体规则,对上一步处理的结果进行规则形式(1)的处理,得到魔王所说的话的人类语言结果。

",写结果文件按照所读入的小写字母对应的文字含义,将翻译成的人类语言转换成文字语句,写入文件reult.t某t中。

",读取文件,并统计1.读取文本文件(rule.t某t),将具体规则的对应关系读入数组或链表中2.读取文本文件(mean.t某t),将小写字母及其对应的含义读入数组或链表中",处理规则形式(2)按照规则形式(2)处理魔王所说的话。

[数据结构]魔王语言解释c语言实现

[数据结构]魔王语言解释c语言实现

[数据结构]魔王语言解释c语言实现[基本要求]用下述两条具体规则和上述规则形式(2)实现。

设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母表示可以用大写字母或小写字母代换的变量。

魔王语言可含人的词汇。

(1)B -> tAdA(2)A -> sae[测试数据]B(ehnxgz)B解释成tsaedsaeezegexenehetsaedsae【实现】将需要解释的魔王语言当成一个字符数组,入栈1。

再依次出栈,入栈2,依次处理顶端字符,若是开括号逐一出栈入队列,直至闭括号出栈。

再逐一出队列,按照规则2解释,再重新入栈2。

出栈2,按照规则1解释。

1.#include <stdio.h>2.#include<stdlib.h>3.#include<string.h>4.#include<malloc.h>5.6.typedef struct Node //节点7.{8.char data;9.struct Node *next;10.}Node,*NodePtr;11.12.typedef struct Stak //栈链表13.{14.NodePtr top;15.NodePtr bot;16.int count;17.}Stak;18.19.//初始化栈20.void InitStak(Stak *ts)21.{22.ts->top = (NodePtr)malloc(sizeof(Node));23.if (NULL == ts->top)24.{25.printf("分配失败");26.exit(-1);27.}28.ts->bot = ts->top;29.ts->count = 0;30.ts->top->next = NULL;31.32.}33.34.//入栈35.void Push(Stak *S, char e)36.{37.NodePtr pnew = (NodePtr)malloc(sizeof(Node));38.pnew->data = e;39.pnew->next = S->top;40.S->top = pnew;41.S->count++;42.43.}44.45.//出栈46.char Pop(Stak *S)47.{48.49.NodePtr p;50.if (S->bot == S->top)51.{//空时返回1 删除失败52.exit(1);53.}54.p = S->top;55.char e = p->data;56.S->top = S->top->next;57.free(p);58.S->count--;59.return e;60.61.}62.63.//打印栈64.void prin(Stak *S)65.{66.NodePtr p;67.p = S->top;68.69.while (p != S->bot)70.{71.printf("%c\n",p->data);72.p = p->next;73.}74.}75.76.bool EmptyStack(Stak *S)77.//判断是否空栈78.{79.if (S->count == 0)80.return 1;81.return 0;82.}83.84.typedef struct QNode //队列节点85.{86.char data;87.struct QNode *next;88.}QNode,*QNodePtr;89.90.typedef struct LinkQueue //队列链表91.{92.QNodePtr front, rear;93.}Queue;94.95.//队列初始化96.void InitQue(Queue *Q)97.{98.QNodePtr p = (QNodePtr)malloc(sizeof(QNode));//p为头节点99.p->data = NULL;100.p->next = NULL;101.Q->front = p;102.Q->rear = p;103.}104.105.//入队列106.void EnQue(Queue *Q, char e)107.{108.QNodePtr p = (QNodePtr)malloc(sizeof(QNode)); 109.p->data = e;110.p->next = NULL;111.Q->rear->next = p;112.Q->rear = p;113.}114.115.char DeQue(Queue *Q)116.//出队列117.{118.QNodePtr p;119.char c;120.if (Q->front == Q->rear)121.{//空时122.exit(1);123.}124.p = Q->front->next;125. c = Q->front->next->data;126.Q->front->next = p->next;127.if (p == Q->rear)128.{129.Q->rear = Q->front;130.}131.free(p);132.133.return c;134.}135.136.void pri(Queue *Q)137.//打印队列138.{139.QNodePtr p;140.p = Q->front;141.if (p != NULL)142.{143.while (p != Q->rear)144.{145.printf("%c", p->next->data); 146.p = p->next;147.}148.}149.150.}151.152.bool EmptyQue(Queue *Q) 153.{154.if (Q->front == Q->rear) 155.return 1;156.return 0;157.}158.159.void Reverse(char M[], Stak *S) 160.{161.int i;162.int len = strlen(M);163.int l = 0, r = 0;164.for (i =0; i <len; i++)165.{166.Push(S, M[i]); 167.if (M[i] == '(') 168.l++;169.if (M[i] == ')') 170.r++;171.}172.if (l != r)173.exit(1);174.}175.176.void EnA(Queue *Q) 177.//规则1178.{179.EnQue(Q, 's'); 180.EnQue(Q, 'a'); 181.EnQue(Q, 'e'); 182.}183.184.void EnB(Queue *Q) 185.//规则1186.{187.EnQue(Q, 't'); 188.EnA(Q);189.EnQue(Q, 'd'); 190.EnA(Q);191.}192.193.void Fpri(Queue *Q) 194.{195.char c;196.while (!EmptyQue(Q))197.{198. c = DeQue(Q);199.switch (c)200.{201.case 't':printf("天"); break;202.case 'd':printf("地"); break;203.case 's':printf("上"); break;204.case 'a':printf("一只"); break;205.case 'e':printf("鹅"); break;206.case 'z':printf("追"); break;207.case 'g':printf("赶"); break;208.case 'x':printf("下"); break;209.case 'n':printf("蛋"); break;210.case 'h':printf("恨"); break;211.default: printf("Error");212.}213.214.}215.}216.217.void Tran(Stak *Sbe,Stak *Saf,Queue *Q ) 218.{219.char c;220.char d;221.int i=0;222.while (Sbe->count != 0)223.{224.225. c = Pop(Sbe);226.227.if (c == ')')228.i = Saf->count;229.else if (c == '(')230.{231.int j = Saf->count;232.while ( j > i )233.{234. d = Pop(Saf);235.EnQue(Q, d);236.j--;237.}238.char e = Q->front->next->data; 239.DeQue(Q);240.while (!EmptyQue(Q))241.//规则2242.{243.char dl = DeQue(Q);244.Push(Saf, e);245.Push(Saf, dl);246.}247.Push(Saf, e);248.}249.else250.Push(Saf, c);251.}252.253.while (Saf->count>0)254.{255.char en;256.en = Pop(Saf);257.if (en == 'A')258.EnA(Q);259.else if (en == 'B') 260.EnB(Q);261.else262.EnQue(Q,en);263.}264.Fpri(Q);265.}266.267.268.int main()269.{270.Stak Sf,St;271.InitStak(&Sf);272.InitStak(&St);273.Queue Qu1;274.InitQue(&Qu1);275.char M[] = "B(ehnxgz)B"; 276.Reverse(M, &Sf); 277.Tran(&Sf, &St, &Qu1); 278.getchar();279.return 0;}。

数据结构算术表达式求值&魔王语言解释

数据结构算术表达式求值&魔王语言解释

一.实验目的1.深入了解栈和队列的特性,以便在实际问题背景下灵活运用他们,同时还将巩固对栈和队列这两种结构的构造方法的理解。

2.加深对mfc的理解。

3.加深对浮点型,字符型,整型之间的转换的熟悉。

二.实验内容1.表达式求值:表达式计算是实现程序设计语言的基本问题,也是栈的应用之一。

设计一个程序,演示用算符优先法对算术表达式求值过程。

2.魔王语言解释:有一个魔王总是使用自己的一种非常精练而抽象的语言讲话,没有人能听得懂,但他的语言是可以逐步解释承认能听懂的语言,因为他的语言是有以下两种形式的规则由人的语言逐步抽象上去的:(1)α→β1β2…βm(2)(θδ1δ2…δn)→θδnθδn-1…θδ1θ在这两种形式中,从左到右均表示解释。

试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话。

三.实验步骤(可选)一.表达式求值:此次实验我用了mfc来做,实现了计算器界面的仿真,拓展了程序的功能,使到该程序不仅可以计算整型,还可以计算浮点型,负数;有判断键入的表达式格式的正误,删除错误输入,清除结果的功能;拓展了运算符,增加了平方的运算,分数化的运算,还有说明界面,计算结果序列化、读取序列化结果的功能。

1.定义栈数据类型;2.定义栈的操作,初始化,出栈,入栈;3.编写运算符优先比较函数precede;4.编写计算表达式的函数express;5.编写序列化函数archieve;6.设计计算器仿真界面;7.添加关联变量,编写相关函数。

具体代码如下://栈定义typedef struct {char* base;char* top;int stacksize;}stack;void initstack(stack &s){s.base=(char*)malloc(sizeof(char)*100);s.top=s.base;s.stacksize=100;}char gettop(stack s){char e;e=*(s.top-1);return e;}void push(stack &s,char e){*s.top++=e;}void pop(stack &s,char &e){e=*--s.top;}bool stackisempty(stack s)//empty?{if(s.top==s.base)return 1;else return 0;}char precede(char a,char b) //比较优先级函数{switch(a){case'+':switch(b){case'+':case'-':case'#':case')':return '>';case'*':case'/':case'^'://scase'(':return '<';}case'-':switch(b){case'+':case'-':case'#':case')':return '>';break; case'*':case'/':case'^'://scase'(':return '<';break; }case'*':switch(b){case'#':case'+':case'-':case')':case'*':case'/':return '>';case'^'://scase'(':return '<';}case'/':switch(b){case'#':case'+':case'-':case')':case'*':case'/':return '>';case'^'://scase'(':return '<';}case'(':if(b==')')return '=';elsereturn '<';case')':return '>';case'#':if(b!='#') return '<';else return '=';case'^'://sswitch(b){case'(':return '<';default:return '>';}}}float operate(float a,char s,float b)//运算符操作结果函数{float res=0;switch(s){case'+':res=a+b;break;case'-':res=a-b;break;case'*':res=a*b;break;case'/':res=a/b;break;case'^':res=a*a;break;}return res;}int check(CString str){int lf=0,rg=0;for(int n=0;n<str.GetLength();n++){if(str[n]=='(')lf++;if(str[n]==')')rg++;if(rg>lf)return 1;if(n<str.GetLength()-1)if(!isnum(str[n])&&!isnum(str[n+1])&&str[n+1]!='-'&&str[n+1]!='('&&str[n]!=')')//两个操作符相连return 2;}if(lf!=rg)return 1;//括号不匹配if(!isnum(str[str.GetLength()-1])&&str[str.GetLength()-1]!=')'||(!isnum(str[0])&&str[0]!='('&&str[0]!='-'))//最后一个或第一个是操作付return 2;return 0;//正确返回零}float expression(CString s)//求值函数{stack shu;//数字栈stack fu;//操作符栈initstack(shu);initstack(fu);int n=0;//表达式索引int oc=0;//字符变浮点控制变量float a=0,b=0;//a暂存操作数1,b暂存操作数2,c暂存操作结果c=0;char tem1,tem2,tem3;//弹出中间变量CString st;//把浮点型变成字符型push(fu,'#');//标志表达式开始push(shu,'a');//a标志数的分隔for(;gettop(fu)!='#'||s[n]!='#';oc=0){if(s[n]>=48&&s[n]<=57||s[n]=='.'||(s[n]=='-'&&n==0))//字符为数字或点则入数字栈{push(shu,s[n]);if(n<s.GetLength())n++;}//ifelseif(s[n]=='-')//判断—是减号还是负号switch(s[n-1]){case'+':case'-':case'*':case'/':case'(':push(shu,s[n]);//s【n-1】是以上结果的话,“—”则是负号,入数字栈if(n<s.GetLength())n++;break;default://其他为负号goto youxian;//去比较优先级}//switchelseyouxian: switch(precede(gettop(fu),s[n]))//比较优先级{case'<':push(fu,s[n]);if(s[n]!='(')push(shu,'a');if(n<s.GetLength())n++;break;case'=':pop(fu,tem1);if(n<s.GetLength())n++;break;case'>':pop(fu,tem1);a=0;for(pop(shu,tem2);tem2!='a';pop(shu,tem2))//字符转换成浮点{if(tem2=='-')a=0-a;elseif(tem2=='.'){a=a/pow(10,oc);oc=0;}elsea=(tem2-48)*pow(10,oc++)+a;}//foroc=0;b=0;for(pop(shu,tem3);tem3!='a';pop(shu,tem3))//字符转换成浮点{if(tem3=='-')b=0-b;elseif(tem3=='.'){b=b/pow(10,oc);oc=0;}elseb=(tem3-48)*pow(10,oc++)+b;}//forc=operate(b,tem1,a);if(a==0&&tem1=='/'){MessageBox(NULL,"除数不能为0!",0,0);c=0;zero=1;return 0;}st.Format("%g",c);if(st.GetLength()>=5&&st[st.GetLength()-5]=='e')//科学计数法则要转换change(st);push(shu,'a');oc=0;for(;oc<st.GetLength();oc++)//压入cpush(shu,st[oc]);}//switch}//maxforc=0;oc=0;for(pop(shu,tem2);tem2!='a';pop(shu,tem2))//字符转换成浮点{st.Format("%g",c);//MessageBox(NULL,st,0,0);if(tem2=='-')c=0-c;elseif(tem2=='.'){c=c/pow(10,oc);oc=0;}elsec=(tem2-48)*pow(10,oc++)+c;}//forreturn c;}二.魔王语言解释:(mfc实现)1.定义栈数据类型;2.定义栈的操作,初始化,出栈,入栈;3.编写魔王语言解释函数及将小写字母和中文建立一一对应关系;4.运行调试。

魔王语言实验报告

魔王语言实验报告

数据结构课内实验报告书一、实验题目:魔王语言解释二、实验目的:通过本次实验,熟练掌握抽象数据类型栈和队列的实现,学会使用栈和队列解决具体应用问题,从而体会栈和队列的特点。

三、实验要求:有一个魔王总是使用自己的一种非常精练而抽象的语言讲话,没有人能听得懂,但他的语言是可以逐步解释承认能听懂的语言,因为他的语言是有以下两种形式的规则由人的语言逐步抽象上去的:(1)α→β1β2…βm(2)(θδ1δ2…δn)→θδnθδn-1…θδ1θ在这两种形式中,从左到右均表示解释。

试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话。

要求:用下述两条具体规则和上述规则形式(2)实现。

设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母表示可以用大写字母或小写字母代换的变量。

魔王语言可含人的词汇。

(1)B→tAdA(2)A→sae四、测试数据:B(ehnxgz)解释成Btsaedaseezegexenehetsaedsae若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是:“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。

五、设计与实现过程(1)栈或队列的定义及其主要操作的实现typedef struct{char *top;char *bace;}Node;(2)主要算法的描述①、定义变量#define STACK_INIT_SIZE 100 #define STACK_INCREMENT 10②、主要代码:int print(Node *stack, char *bace){while(bace != stack->top) {printf("%c", *bace);bace++;}return 0;}int fun(Node *stack, char top[], char array[][20], char **bace, char *b) {Node stack1;char *point;char e, g;int k, i, a = 0, found = 0;initstack(&stack1,&point);g = getchar();while(g != '\n') {if(g == ')')break;if(g >= 'A' && g <= 'Z') {k = strlen(array[g - 'A']);if(found == 0){*(top++) = array[g - 'A'][0];found = 1;}for(i=0 ;i<k; i++)push(&stack1,&array[g - 'A'][i],&point);} else {if(g == '('){fun(&stack1, top, array, &point, &g);break;} else if(g != ')') {if(found == 0){*(top++) = g;found = 1;}push(&stack1, &g, &point);}}g = getchar();}top--;while(stack1.bace != stack1.top) {push(stack, top, bace);pop(&stack1, &e);push(stack, &e, bace);}pop(stack, &e);free(stack1.bace);return 0;}六、技巧与体会通过这次试验,我对有关栈和队列的知识更加熟悉、为后面所学的知识奠定了良好的基础、同时也使自己有了编程的技巧!以后要加强动手时间能力、多与同学交流算法精髓!在编写程序中尽量做到独立完成、对于自己想要完成的问题要主动编程完成、这样自己是一个很大的提升、也能学到很多的知识、熟练编程!。

魔王语言

魔王语言

西安郵電學院数据结构课程设计报告题目:魔王语言系部名称:通信与信息工程学院专业名称:通信工程班级:通工0905学号:03091183学生姓名:李辉指导教师:王小银时间:2010年11月15日至2010年11月24日一.实验目的(1)通过实验加深对线性表、栈、队列的掌握和应用。

(2)通过实验提高自己整合所学C语言及数据结构知识分析和解决实际问题的能力。

(3)进一步提高自己的编程水平。

二.实验内容及思想(1)问题描述:有一个魔王总是使用自己的一种非常精炼而抽象的语言讲话,没有人能听懂。

但他的语言是可以逐步解释成人能懂的语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α→β1β2 ……βm(2)(θδ1δ2 ……δn)→θδnθδn-1 ……θδ1 θ在这两种形式中,从左到右均表示解释;从右到左均表示抽象。

试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话。

(2)算法思想:算法主思想:①判断魔王语言大写转换成小写、小写转换成人类语言的规则是否存在,若存在则直接读出并保存在相应的单链表中,若不存在则予以创建并保存在对应的文件中。

②将输入的魔王语言存入字符数组,并逆序入栈利用递归的方法进行去括号操作。

③采用递归法对去完括号后的字符序列进行大写化小写操作。

④将经过③处理后得的小写字母序列利用字符串比较、插入等方法转换成人类语言,并把小写字母序列和翻译后的人类语言保存在result.txt文件中。

去括号思想:定义字符变量temp, 定义flag=0,当flag=1时进行递归。

采用while循环把输入的魔王语言从右自左依次逆序入栈s,当栈s不为空且没遇到右括号时依次出栈s,进栈s1,当遇到右括号时flag=1。

采用while循环元素出栈s1入队q直到遇到左括号,入队结束(左括号不入队),此时temp为左括号后的元素。

然后,当队q不为空时依次出队,令temp和出队元素依次入队s1,将多入队的元素删除一个。

魔王语言解释(数据结构课程设计)

魔王语言解释(数据结构课程设计)

魔王语言解释1、绪论1.1 背景随着网络技术的发展,网络安全变得越来越重要,文件加密是其中一个重要部分。

而“魔王语言”就是一个简单的文件加密。

“魔王语言”就是有一个魔王总是使用自己的一种非常精练而又抽象的语言讲话,没有人能听得懂,但他的语言是可以逐步解释成人能听懂的语言,因为他的语言是有规则的,可以通过相应的规则来解释。

1.2研究目的通过这次设计,要求在数据结构逻辑特性和物理分析、数据结构的选择和应用、算法的设计及其实现等方面,加深对基础知识的理解。

同时,在程序设计方法以及上机造作等基本技能方面受到严格的训练。

2、需求分析2.1 题目魔王语言解释。

2.2 基本要求魔王的话没有人能听得懂,但他的语言是可以逐步解释成人能听懂的语言,有着下面的基本要求:用下述两条具体规则和下述规则形式2)实现。

设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母表示可以用大写字母或小写字母代换的变量。

魔王语言可含人的词汇。

以下是他的语言的两种形式的规则有语言逐步抽象上去的:1)α 转换为β1β2…βm2)(θδ1δ2…δn)转换为θδnθδn-1… θδ1θ在这两种形式重,从左到右均表示解释。

试写一个魔王语言的解释兄,把他的话解释成人能听得懂的话。

因此,我们编写了一个有趣的魔王语言解释程序来巩固和加强对栈和队列的理解。

以下是他的语言的两种形式的具体规则:⑴A 转换为hdwhz,B 转化为hasff,C 转化为hwhll,D 转化为hkhbf,E 转化为hkwsx,F 转化为hxwsb。

⑵h 转化为“花”,d 转化为“蝴蝶”,w 转化为“为”,z 转化为“醉”,s 转化为“随”,fe 转化为“风”,f 转化为“飞”,k 转化为“开”,ku 转化为“哭”,b 转化为“悲”,x 转化为“谢”,l 转化为“落泪”,ba 转化为“瓣”。

⑶A 转化为“蝴蝶为花瓣”,B 转化为“花却随风飞”,C 转化为“花舞花落泪”,D 转化为“花哭花瓣飞”,E 转化为“花开为谁谢”,F 转化为“花谢为谁悲”。

魔王语言解释-数据结构课程设计

魔王语言解释-数据结构课程设计

在这两种形式中, 从左到右均表示解释。 试写一个魔王解释系统, 把他的话解释成人能
听懂得话。
2. 基本要求
用下述两条具体规则和上述规则形式( 2)实现。 设大写字母表示魔王语言的词汇;小写
字母表示人的语言词汇; 希腊字母表示可以用大写或小写字母代换的变量。
魔王语言可含人
的词汇。
( 1) B— >tAdA
将魔王的语言自右至左进栈,总是处理栈顶字符。若是开括号,则逐一出栈,将字母顺
序入队列, 直至闭括号出栈,并按规则要求逐一出队列再处理后入栈。
其他情形较简单,请
读者思考如何处理。应首先实现栈和队列的基本操作。
二、 概要设计
1、 设定栈的抽象数据类型定义: ADT Stack { 数据对象: D= {a i| ai∈ CharSet, i= 1,2, ,, n,. n≥ 0 } 数据关系: R1={ <a i-1 ,ai> | ai-1 ,ai∈ D, ai-1<ai ,i=1,2 ,, ,n} 基本操作:
数据关系: R1={< ai-1,ai > |ai-1,ai ∈ Dt i= 1,2, ,, n}
基本操作:
InitQueue (*Q)
操作结果:构造一个空队列 Q。
EnQueue( *Q,e)
初始条件:队列 Q 已经存在。 操作结果:插入元素 e 为 Q 的新的队尾元素。
DeQueue(*Q,*e )
s->top=s->base; }
void InitQueue(LinkQueue *q) {// 构造一个空队列
q->front=q->rear=(QNote*)malloc(sizeof(QNote)); q->front->next=NULL; }

魔王语言解释课程设计报告

魔王语言解释课程设计报告

课程设计(数据结构)班级姓名学号指导教师课程设计任务书及成绩评定课题名称魔王语言解释系统设计Ⅰ、题目的目的和要求:1、设计目的巩固和加深对数据结构的理解,通过上机实验、调试程序,加深对课本知识的理解,最终使学生能够熟练应用数据结构的知识写程序。

(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。

魔王语言tdsaexghnAtx解释成txtttsaetnthtgtztetatstdtⅡ、设计进度及完成情况日期内容1.10-1.11 选取参考书,查阅有关文献资料,完成资料搜集和系统分析工作。

1.12~1.14 创建相关数据结构,录入源程序。

1.17~1.19 调试程序并记录调试中的问题,初步完成课程设计报告。

1.20~1.21 上交课程设计报告打印版并进行课程设计答辩,要求每个同学针对自己的设计回答指导教师3-4个问题。

考核结束后将课程设计报告和源程序的电子版交班长统一刻光盘上交。

Ⅲ、主要参考文献及资料[1] 严蔚敏数据结构(C语言版)清华大学出版社 1999[2] 严蔚敏数据结构题集(C语言版)清华大学出版社 1999[3] 谭浩强 C语言程序设计清华大学出版社[4] 与所用编程环境相配套的C语言或C++相关的资料Ⅳ、成绩评定:设计成绩:(教师填写)指导老师:(签字)二○一一年一月二十一日目录第一章概述 (1)第二章系统分析 (2)第三章概要设计………………………………………………………第四章详细设计………………………………………………………第五章运行与测试……………………………………………………第六章总结与心得……………………………………………………参考文献………………………………………………………………第一章概述课程设计是实践性教学中的一个重要环节,它以某一课程为基础,可以涉及和课程相关的各个方面,是一门独立于课程之外的特殊课程。

魔王语言解释

魔王语言解释

1、绪论1.1 背景随着网络技术的发展,网络安全变得越来越重要,文件加密是其中一个重要部分。

而“魔王语言”就是一个简单的文件加密。

“魔王语言”就是有一个魔王总是使用自己的一种非常精练而又抽象的语言讲话,没有人能听得懂,但他的语言是可以逐步解释成人能听懂的语言,因为他的语言是有规则的,可以通过相应的规则来解释。

1.2研究目的通过这次设计,要求在数据结构逻辑特性和物理分析、数据结构的选择和应用、算法的设计及其实现等方面,加深对基础知识的理解。

同时,在程序设计方法以及上机造作等基本技能方面受到严格的训练。

2、需求分析2.1 题目魔王语言解释。

2.2 基本要求魔王的话没有人能听得懂,但他的语言是可以逐步解释成人能听懂的语言,有着下面的基本要求:用下述两条具体规则和下述规则形式2)实现。

设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母表示可以用大写字母或小写字母代换的变量。

魔王语言可含人的词汇。

以下是他的语言的两种形式的规则有语言逐步抽象上去的:1)α 转换为β1β2…βm2)(θδ1δ2…δn)转换为θδnθδn-1… θδ1θ在这两种形式重,从左到右均表示解释。

试写一个魔王语言的解释兄,把他的话解释成人能听得懂的话。

因此,我们编写了一个有趣的魔王语言解释程序来巩固和加强对栈和队列的理解。

以下是他的语言的两种形式的具体规则:⑴B 转换为他tAdA,A 转化为sae.⑵t转化为”天”, d转化为"地",s转化为"上",a转化为"一只",e转化为"鹅",z转化为"追",g转化为"赶",x转化为"下",n转化为"蛋",h转化为”恨”. 2.3数据测试B(ehnxgz)B解释成tsaedsaeezegexenehetsaedsae若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是:”天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”2.4实现分析⑴以一维数组demon[ i ]表示魔王语言.⑵魔王语言由用户输入,初始保存在demon[ i ]中.⑶魔王语言与人类语言对应关系固化在程序中.2.5实现过程⑴初始,魔王语言接收后存放在demon[ i ]中.⑵遍历数组,将数组中括号内的元素入栈,同时插入相应首字母;⑶再次遍历数组,将数组元素依次入队。

数据结构课程设计完整版

数据结构课程设计完整版

西安郵電學院数据结构课程设计报告题目:魔王语言翻译/多项式相乘系部名称:专业名称:班级:学号:学生姓名:指导教师:时间:一、课程设计目的通过本次课程设计,强化上机动手能力,使我们在理论和实践的基础上进一步巩固《C语言程序设计》、《数据结构——使用C语言》课程学习的内容,初步掌握工程软件设计的基本方法,熟知链表,栈,队以及文件的使用方法,学会将知识应用于实际,提高分析和解决问题的能力,为毕业设计和以后工作打下基础。

二、课程设计内容【1】、魔王语言问题描述有一个魔王总是使用自己的一种非常精炼的而抽象的语言讲话,没有人能听懂。

但他的语言是能够逐步解释成人能听懂的语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α→β1β2 ……βm(2)(θδ1δ2 ……δn)→θδnθδn-1 …… θδ1 θ在这两种形式中,从左到右均表示解释;从右到左均表示抽象。

试写一个魔王语言的解释系统,把他的话解释成人能听懂的话。

基本规则现在有以下三种规则,设大写字母表示魔王语言解释的词汇,小写字母表示人的语言的词汇;希腊字母表示可以用大写或小写替换的变量。

魔王语言可含人的词汇。

(1)B->tAdA(2)A->sae(3)示例:魔王说:B(ehnxgz)B解释成人的语言:tsaedsaeezegexenehetsaedsae若每个小写字母含义如下表示:t d s a e z g x n h天地上一只鹅追赶下蛋恨则魔王说的话是:天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅【2】、多项式相乘问题描述用带头结点的动态单链表来表示多项式,在此基础上完成多项式的乘法运算。

三、需求分析对所开发系统功能、性能的描述,想要实现的目标。

【1】魔王语言有一个魔王总是使用自己的一种非常精炼的而抽象的语言讲话,没有人能听懂。

但他的语言是能够逐步解释成人能听懂的语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实习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。

ClearStack(*S)初始条件:栈S已存在操作结果:将栈S清空。

InStack(char* ch,SqStack *s)初始条件:栈S已存在操作结果:把字符数组从右至左压入栈中。

}ADT StackADT Queue{数据对象:D={ai | ai∈CharSet i= 1,2,……n,. n≥0 }数据关系:R1={< ai-1,ai > |ai-1,ai∈D t i= 1,2,……n}基本操作:InitQueue (*Q)操作结果:构造一个空队列Q。

EnQueue(*Q,e)初始条件:队列Q已经存在。

操作结果:插入元素e为Q的新的队尾元素。

DeQueue(*Q,*e)初始条件:队列Q已经存在。

操作结果:删除Q的对头元素,并以e返回其值。

QueueEmpty(Q)初始条件:队列Q已经存在。

操作结果:若队列Q为空栈,则返回1,否则返回0。

}ADT Queue三、详细设计(源代码)(使用C语言)#include<stdio.h>#include<stdlib.h>#define STACK_INIT_SIZE 100//存储空间初始分配量#define STACKINCREMENT 10//存储空间分配增量typedef struct{char* base;//栈底指针char* top;//栈顶指针int stacksize;}SqStack;typedef struct QNote{char data;struct QNote *next;}QNote,*QueuePtr;typedef struct{QueuePtr front;//队头指针QueuePtr rear;//队尾指针}LinkQueue;void InitStack(SqStack *s){//构造一个空栈s->base=(char*)malloc(STACK_INIT_SIZE*sizeof(char));s->top=s->base;s->stacksize=STACK_INIT_SIZE;}void Push(SqStack *s,char e){//插入元素e为新的栈顶元素if(s->top-s->base>=STACK_INIT_SIZE){s->base=(char*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(char));s->top=s->base+s->stacksize;s->stacksize+=STACKINCREMENT;}*(s->top)=e;s->top++;}void Pop(SqStack *s,char *e){//元素e出栈*e=*--s->top;}int StackEmpty(SqStack s){//判断栈是否为空if(s.top==s.base)return 1;else return 0;}void ClearStack(SqStack *s){//清空栈s->top=s->base;}void InitQueue(LinkQueue *q){//构造一个空队列q->front=q->rear=(QNote*)malloc(sizeof(QNote));q->front->next=NULL;}void EnQueue(LinkQueue *q,char e){//插入元素e为新的队尾元素QNote *p;p=(QNote*)malloc(sizeof(QNote));p->data=e;p->next=NULL;q->rear->next=p;q->rear=p;}void DeQueue(LinkQueue *q,char *e){//元素出队QNote *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(LinkQueue q){//判断队列是否为空if(q.front==q.rear)return 1;elsereturn 0;}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]);}int main(){printf("**************************************************************\n");printf("* **************************** *\n");printf("* * 魔王语言解释系统* *\n");printf("* **************************** *\n");printf("**************************************************************\n");int xunhuan=1;printf("请输入您想要解释的魔王语言:\n");while (xunhuan==1) //一个总循环控制整个程序的重复进行{char A[]="sae"; //大写字母作为字符数组名存放小写字母char B[]="tsaedsae";char flag='0'; //flag用来标记处理括号char e1,key,e2,e,i=0;int mark=1; //标记输入的魔王语言是否在允许的范围之内int f=1; // 判断括号是否匹配char MoWang[100]="\0"; //定义一个魔王变量,存放待解释的语言字符SqStack S; //作为栈存储元素,为后续操作和输出做准备SqStack temp; //用来处理括号外的元素InitStack(&S);InitStack(&temp);LinkQueue Q;InitQueue(&Q);gets(MoWang); //变量MoWang存储输入的语言InStack(MoWang,&S); //把要解释的魔王语言压入栈中while(!StackEmpty(S)) //把魔王语言进行出栈,不符合语言的进行提示{Pop(&S,&e1);if(e1=='('){if(StackEmpty(S)){printf("魔王语言错误!\n");mark=0;f=0;break;}while(!StackEmpty(S)){Pop(&S,&e1);if(e1==')'){if(i==0)//判断是否存在空括号(本程序设空括号为非法语言)f=0;break;}else if(!(e1>='a'&&e1<='z')&&!(e1>='A'&&e1<='Z')){printf("魔王语言错误!\n");mark=0;break;}i++;}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)) //栈不空时,用栈temp进行存储不带括号内元素的元素{Pop(&S,&e1);if(e1=='B'||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); //将队头的元素赋值给key }elsePush(&temp,e1);}while(!StackEmpty(temp)) //将魔王说的语言规则地压入栈s中{Pop(&temp,&e1);if(e1!=flag)Push(&S,e1); //把括号外的元素压入栈s中else{while(!QueueEmpty(Q)) //处理括号中的元素进栈{DeQueue(&Q,&e2);Push(&S,key);Push(&S,e2);}Push(&S,key); //最后还要压一个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");}printf("再次输入魔王语言(按数字键0退出)\n");scanf("%d",&xunhuan);}return 0;}四、调试分析编译环境为CodeBlocks。

相关文档
最新文档