魔王语言解释-大数据结构课程设计
魔王语言解释报告
实习报告题目:魔王语言解释班级:xxx姓名:xxx学号:xxx完成日期:2011.5.29一:需求分析(1)以一维数组Devil[ i ]表示魔王语言.(2)魔王语言由用户输入,初始保存在Devil[ i ]中.(4)实现过程:A:初始,魔王语言接收后存放在Devil[ i ]中.B:初次遍历数组,将数组中括号内的元素入栈,同时插入相应首字母;C:再次遍历数组,将数组元素依次入队。
小写字母直接入队;大写字母经翻译成相应字符后入队;遇到括号,将栈中保存的元素依次出栈入队,如果依旧包含大写字母,则flag为1,否则为0。
D:将队列中元素赋值给Devil[i].如果flag=1,则再次重复C过程。
直至所有元素为人类语言。
E:输出Devil[ 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)主函数模块.其中主函数为:int main(){初始化栈;初始化队列;接收魔王语言输入到数组Devil[i ];遍历数组将括号中元素进栈;while(数组Devil[i ]中元素有大写字母){ 翻译排序处理后入队列;将对列元素保存在数组Devil[i ];}输出人类语言(数组Devil[ i]);}2)括号内元素入栈处理模块.tempstack(&temps)将括号内元素入栈,依次插入首字符.举例:(abcd)->adacaba.3)排序入队列模块.sort(&s,&q){遍历数组;{遇到小写字母,直接入队列;遇到大写字母,翻译大写后入队列;遇到括号,将栈中保存的元素依次出栈入队列;}}4)翻译大写处理模块.spenqueue(&*q,key){switch(key){找到各个大写字母对应的字符串.没有相应的则解释为’???’}}各模块之间调用关系:主函数模块{括号内元素入栈处理模块;排序入队模块{翻译大写处理模块;}}三:详细设计1.定义全局变量#define ERROR 0#define NULL 0#define OVERFLOW -2#define MAXSIZE 100#define stack_init_size 100#define stackincrement 10char e;char Devil[MAXSIZE];2.栈类型及其基本操作typedef struct{char *base;char *top;int stacksize;}sqstack;int initstack (sqstack *s){s->base=(char *)malloc(stack_init_size*sizeof(char));if(!s->base) exit (OVERFLOW);s->top=s->base;s->stacksize=stack_init_size;return 1;}/*创建栈*/int push (sqstack *s,char 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;return 1;}/*入栈*/int pop(sqstack *s,char *e){if(s->top==s->base) return ERROR;*e=*(--(s->top));return 1;}/*出栈*/3.队列类型及其基本操作typedef struct qnode{char data;struct qnode *next;}qnode,*queueptr;typedef struct{queueptr front;queueptr rear;}linkqueue;int initqueue(linkqueue *q){q->front=q->rear=(queueptr)malloc(sizeof(qnode)); if(!q->front) exit(OVERFLOW);q->front->next=NULL;return 1;}/*创建队列*/int enqueue(linkqueue *q,char 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 1;}/*入队*/int dequeue(linkqueue *q,char *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 1;}/*出队*/4.括号内元素入栈处理函数void tempstack(sqstack *temps){int i=0;char t;char c;c=Devil[i ];for(i=0;c!='#';i++)/*遍历数组*/{c=Devil[i ];if(c=='(')/*遇到开括号*/{t=Devil[i+1];/*取括号中的首字母*/push(temps,t);/*入栈*/i++;/*指向首字母*/do{i++;c=Devil[i ];push(temps,c)/*第一次循环将次字母入栈*/; push(temps,t);/*再将首字母进栈*/}while(c!=')');/*直到括号中元素全部进栈*/ pop(temps,&t);/*将多余进栈的首字母t出栈*/ pop(temps,&t); /*将多余进栈的’)’出栈*/ }}}/*临时栈*/5.特殊入队函数void spenqueue(linkqueue *q,char key){int j=0;char a[5];switch(key) /*判断大写字母对应的字符串*/{case'A':strcpy(a,"sae");break;case'B':strcpy(a,"tAdA");break;case'C':strcpy(a,"abc");break;case'D':strcpy(a,"def");break;case'E':strcpy(a,"ghi");break;case'F':strcpy(a,"klm");break;case'H':strcpy(a,"mop");break;default:strcpy(a,"???"); /*不能翻译的魔王语言以”???”输出*/}while(a[j]!='\0') /*如果数组还有字母*/{enqueue(q,a[j]);/*进队*/j++;}}/*特殊入队*/6.排序入队处理函数int sort(sqstack *s,linkqueue *q) {qnode b;int flag=0;/*大写字母监视哨置零*/int i;for(i=0;Devil[ i]!='#';i++)/*遍历数组*/{b.data=Devil[ i];if( ('a'<=b.data&&b.data<='z') || b.data=='?') /*如果是小写字母或者’?’则直接入队*/ {enqueue(q,b.data);}else{if('A'<=b.data&&b.data<='Z') /*如果是大写字母,则调用特殊入队函数,*/{spenqueue(q,b.data);flag=1; /*发现大写字母监视哨置1*/}else{if(b.data=='(')/*如果是括号*/{do{pop(s,&e);enqueue(q,e);}while(!(s->top==s->base)); /*只要栈不为空,则出栈进队*/while (b.data!=')') /*只要还指向括号内元素,就继续往后移,保证原括号内的元素不再进栈*/{i++;b.data=Devil[ i];}}}}}return flag;}/*排序*/int main(){sqstack s1;linkqueue q1;int k=0;int flag=1;printf("请输入魔王的话('#'结束?):\n");printf("魔王:");scanf("%s",Devil);initstack(&s1); /*创建栈*/initqueue(&q1); /*创建队*/tempstack(&s1); /*调用函数*/while (flag==1) /*如果有大写字母?*/{k=0;flag=sort(&s1,&q1);while(q1.front!=q1.rear) /*重写Devil[i]*/{dequeue(&q1,&e);Devil[k]=e;k++;}Devil[k]='#';}Devil[k]='\0';printf("\n人类%s\n",Devil);return 1;}/*主函数*/四:调试分析1. 函数调用比较多,因而得仔细对待数值和地址的传递.2. 由于魔王语言中’B’中仍然包含着大写字母(tAdA).所以考虑设置flag.3. 函数数组遍历.进栈出栈.入队出队中都要牵扯指针的移动,所以要仔细考虑一循环的条件以及进栈元素的个数.五:用户手册1.本程序运行环境为DOS,执行文件为:魔王语言.exe,进入后直接写上魔王的话‘#’结束六:测试结果。
数据结构 课程设计报告 魔王语言解释
题目:魔王语言解释[问题描述]有一个魔王总是使用自己的一种非常精练而抽象的语言讲话,没有人能听懂,但他的语言是可以逐步解释成人能听懂的语言,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(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;}四.实验的结果及分析。
魔王语言解释-数据结构课程设计
实习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。
魔王语言报告(带有完整程序)
郵電學院数据结构课程设计报告题目:魔王语言院系名称:专业名称:班级:学生:学号(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.改进方案此次魔王语言的设计,合理之处:使用链式存储结构,位置确定,可以简化思维过程。
魔王语言解释
约瑟夫环实验报告一.需求分析(1)以一维数组M[ i ]表示魔王语言.(2)魔王语言由用户输入,初始保存在M[ i ]中.(3)魔王语言与人类语言对应关系固化在程序中.(4)实现过程:A:初始,魔王语言接收后存放在M[ i ]中.B:初次遍历数组,将数组中括号内的元素入栈,同时插入相应首字母;C:再次遍历数组,将数组元素依次入队。
(小写字母直接入队;大写字母经翻译成相应字符后入队;遇到括号,将栈中保存的元素依次出栈入队)在翻译过程中,如果依旧包含大写字母,则置flag为1,否则为0。
D:将队列中元素赋值给M[ i ]。
如果此时flag=1,则再次重复C过程。
直至所有元素为人类语言。
二.概要设计1:设定栈的抽象数据类型定义2:设定队列的抽象数据类型3:本程序包含四个模块:1)主函数模块.2)括号内元素入栈处理模块.3)排序入队列模块.4)翻译大写处理模块.各模块之间调用关系:主函数模块{括号内元素入栈处理模块;排序入队模块{翻译大写处理模块;}}三.详细设计程序设计如下:#include "stdio.h"#include "string.h"#include "conio.h"#include "stdlib.h"#define MAX 256/*入栈*/void pushstack(char s[],char x,int flag,int *top)/*flag表示入栈种类:1表示翻译入栈。
0表示直接入栈*/{char k[20];int m,i;if(flag==1){if(x=='A'){strcpy(k,"sae");m=strlen(k);for(i=0;i<m;i++){if(*top>MAX-1){printf("上溢!");exit(0);}elses[++(*top)]=k[m-1-i];}}else if(x=='B'){strcpy(k,"tsaedsae");m=strlen(k);for(i=0;i<m;i++){if(*top>MAX-1){printf("上溢!");exit(0);}elses[++(*top)]=k[m-1-i];}}elses[++(*top)]=x;}elses[++(*top)]=x;}/*字典*/void charmap(char x){switch(x){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 'i': printf("恨"); break;default : break;}}int main (void){char s1[MAX],s2[MAX],d[MAX];int flag=0,i,t;int top1=-1,top2=-1,front=-1,rear=-1;printf("请输入魔王语言:\n");scanf("%s",s2);t=strlen(s2);for(i=0;i<t;i++)pushstack(s1,s2[t-1-i],0,&top1);while(top1!=-1){if(s1[top1]=='('){t=s1[--top1];d[++rear]=s1[top1--];while(s1[top1]!=')'){d[++rear]=s1[top1--];d[++rear]=t;}top1--; /*让‘)’不入栈*/flag=0; /*初始计数标志,记录括号后面的字母的个数*/}pushstack(s2,s1[top1--],0,&top2); /*将括号外面的字母入栈*/flag++;}while((flag--)!=0)pushstack(s1,s2[top2--],1,&top1);while(rear!=front)pushstack(s1,d[++front],1,&top1); /*出队入栈*/while(top2!=-1)pushstack(s1,s2[top2--],1,&top1);printf("魔王语言翻译成人的语言是:\n");while(top1!=-1)/*最终栈s1中存着翻译好的字母*/{charmap(s1[top1--]);/*printf("%c",s1[top1--]); */}getch();}四.调试分析1. 函数调用比较多,因而得仔细对待数值和地址的传递.2. 由于魔王语言中’B’中仍然包含着大写字母(tAdA).所以考虑设置flag.3. 函数数组遍历.进栈出栈.入队出队中都要牵扯指针的移动,所以要仔细考虑一循环的条件以及进栈元素的个数.五.用户手册1.该程序在windows系统下运行2.输入时输入要解释的字母运行输出即可六.测试结果输入ehnxgz七.附录#include "stdio.h"#include "string.h"#include "conio.h"#include "stdlib.h" #define MAX 256。
魔王语言解释
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.排序入队处理函数
魔王语言 数据结构试验报告
课程题目魔王语言系统解释一、需求分析[问题描述]有一个魔王总是使用自己的一种非常精练而抽象的语言讲话,没人能听的懂。
但他的语言是可以逐步解释成人能懂得语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α->β1β2...βn(θδ1δ2...δn)->θδnθδn-1...θδ1θ在这两种形式中,从左到右均表示解释;从右到左表示抽象。
试写一个魔王解释系统,把他的话解释成人能听懂得话。
[基本要求]用下述两条具体规则和上述规则形式(2)实现。
设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母(a,b1,s,y1等)表示可以用大写或小写字母代换的变量。
魔王语言可含人的词汇。
(1) B->tAdA(2) A->sae[测试数据]B(einxgz)B解释成tsaedsaeezegexeneietsaedsae若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是“天上一个鹅地上一个鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一个鹅地上一个鹅。
”[实现提示]将魔王的语言自右至左进栈,总是处理栈顶。
若是开括号,则逐一出栈,将字母顺序入队列,直至闭括号出栈,并按规则要求逐一出队列再处理后入栈。
其他情形较简单,请读者思考如何处理,应首先实现栈和队列的基本运算二、概要设计为实现上述程序功能,应以栈和队列来表示。
1.设定栈的抽象数据类型定义为:ADT Stack{数据对象:D={ai | ai∈CharSet,I=1,2,......,n,n≥0}数据关系:R1={< ai-1,ai > |ai-1,ai∈D,I=1,2,......,n}基本操作:ListInitiate (&S)操作结果:构造一个空栈S。
StackEmpty(S)初始条件:栈S已经存在。
操作结果:若栈S为空栈,则返回TRUE,否则返回FALSE。
Push(&S,e)初始条件:栈S已经存在。
魔王语言实验报告
数据结构课程设计报告题目:魔王语言系部名称:通信工程专业名称:班级:学号:学生姓名:指导教师:时间:一、课程设计目的(1)熟练掌握C语言和数据结构的相关操作。
(2)综合应用C语言的知识和数据结构的知识,编写程序,并且对以前所学的知识进行复习。
( 3 ) 培养学生独立完成课程设计的能力。
二、课程设计内容1.用带头结点的动态单链表来存储多项式;在此基础上完成多项式乘法运算要求以动态链表为存储结构、使用到查找和排序等操作;在创建多项式的过程中,可以按指数的任意顺序输入,并且可在同一多项式中输入指数相同的多项;在进行乘法操作之前,输出参与操作的两个多项式。
要求输出的多项式按指数降序排列,同指数的多项合并,项数的正负号显示合理。
2.魔王语言有一个魔王总是使用自己的一种非常精炼而抽象的语言讲话,没有人能听懂。
但他的语言是可以逐步解释成人能懂的语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α→β1β2 ……βm(2)(θδ1δ2 ……δn)→θδnθδn-1 ……θδ1 θ在这两种形式中,从左到右均表示解释;从右到左均表示抽象。
试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话。
读取文件,并统计1. 读取文本文件(rule.txt), 将具体规则的对应关系读入数组或链中2. 读取文本文件(mean.txt), 将小写字母及其对应的含义读入数组或链表中处理规则形式(2)按照规则形式(2)处理魔王所说的话。
处理完毕后,对应的解释语句不再含有()。
处理规则形式(1)按照读入的具体规则,对上一步处理的结果进行规则形式(1)的处理,得到魔王所说的话的人类语言结果。
写结果文件按照所读入的小写字母对应的文字含义,将翻译成的人类语言转换成文字语句,写入文件result.txt中。
读取文件,并统计1. 读取文本文件(rule.txt),将具体规则的对应关系读入数组或链表中2. 读取文本文件(mean.txt), 将小写字母及其对应的含义读入数组或链表中处理规则形式(2)按照规则形式(2)处理魔王所说的话。
数据结构算术表达式求值&魔王语言解释
一.实验目的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...βn(2)(θδ1δ2...δn)->θδnθδn-1...θδ1θ在这两种形式中,从左到右均表示解释;从右到左表示抽象。
试写一个魔王解释系统,把他的话解释成人能听懂得话。
[基本要求]用下述两条具体规则和上述规则形式(2)实现。
设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母(a,b1,s,y1等)表示可以用大写或小写字母代换的变量。
魔王语言可含人的词汇。
(1)B->tAdA(2) A->sae[测试数据]B(einxgz)B解释成 tsaedsaeezegexeneietsaedsae若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是“天上一个鹅地上一个鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一个鹅地上一个鹅。
”t d s a e z G x n i天地上一个鹅追赶下蛋恨[实现提示]将魔王的语言自右至左进栈,总是处理栈顶。
若是开括号,则逐一出栈,将字母顺序入队列,直至闭括号出栈,并按规则要求逐一出队列再处理后入栈。
其他情形较简单,请读者思考如何处理,应首先实现栈和队列的基本运算二、概要设计为实现上述程序功能,应以栈和队列来表示。
1.设定栈的抽象数据类型定义为:ADT Stack{数据对象:D={ai | ai∈CharSet,I=1,2,......,n,n≥0}数据关系:R1={< ai-1,ai > |ai-1,ai∈D,I=1,2,......,n}基本操作:ListInitiate (&S)操作结果:构造一个空栈S。
StackEmpty(S)初始条件:栈S已经存在。
操作结果:若栈S为空栈,则返回TRUE,否则返回FALSE。
魔王语言
西安郵電學院数据结构课程设计报告题目:魔王语言系部名称:通信与信息工程学院专业名称:通信工程班级:通工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 转化为“花谢为谁悲”。
魔王语言解释课程设计报告
课程设计(数据结构)班级姓名学号指导教师课程设计任务书及成绩评定课题名称魔王语言解释系统设计Ⅰ、题目的目的和要求: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)第三章概要设计………………………………………………………第四章详细设计………………………………………………………第五章运行与测试……………………………………………………第六章总结与心得……………………………………………………参考文献………………………………………………………………第一章概述课程设计是实践性教学中的一个重要环节,它以某一课程为基础,可以涉及和课程相关的各个方面,是一门独立于课程之外的特殊课程。
魔王语言解释
实习报告题目:编制一种魔王语言解释旳程序班级:06052711 姓名:曹旭学号:06057104 完毕日期:.11.27一、需求分析[问题描述]有一种魔王总是使用自己旳一种非常精练而抽象旳语言发言,没人能听旳懂。
但他旳语言是可以逐渐解释成人能懂得语言旳,由于他旳语言是由如下两种形式旳规则由人旳语言逐步抽象上去旳:(1)α->β1β2...βn(2)(θδ1δ2...δn)->θδnθδn-1...θδ1θﻫ在这两种形式中,从左到右均表达解释;从右到左表达抽象。
试写一种魔王解释系统,把他旳话解释成人能听懂得话。
[基本规定] ﻫ用下述两条具体规则和上述规则形式(2)实现。
设大写字母表达魔王语言旳词汇;小写字母表达人旳语言词汇;希腊字母(a,b1,s,y1等)表达可以用大写或小写字母代换旳变量。
ﻫ魔王语言可含人旳词汇。
(1)B->tAdA(2) A->sae[测试数据]B(einxgz)B解释成tsaedsaeezegexeneietsaedsae若将小写字母与中文建立下表所示旳相应关系,则魔王说旳话是“天上一种鹅地上一种鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一种鹅地上一种鹅。
” ﻫt d s a ez G x n iﻫ天地上一种鹅追赶下蛋恨[实现提示]将魔王旳语言自右至左进栈,总是解决栈顶。
若是开括号,则逐个出栈,将字母顺序入队ﻫ列,直至闭括号出栈,并按规则规定逐个出队列再解决后入栈。
其他情形较简朴,请读者思考如何解决,应一方面实现栈和队列旳基本运算二、概要设计为实现上述程序功能,应以栈和队列来表达。
1.设定栈旳抽象数据类型定义为:ADTStack{ ﻫ数据对象:D={ai| ai∈CharSet,I=1,2,......,n,n≥0}数据关系:R1={< ai-1,ai > |ai-1,ai∈D,I=1,2,......,n}基本操作: ﻫListInitiate (&S) ﻫ操作成果:构造一种空栈S。
数据结构课程设计完整版
西安郵電學院数据结构课程设计报告题目:魔王语言翻译/多项式相乘系部名称:专业名称:班级:学号:学生姓名:指导教师:时间:一、课程设计目的通过本次课程设计,强化上机动手能力,使我们在理论和实践的基础上进一步巩固《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】魔王语言有一个魔王总是使用自己的一种非常精炼的而抽象的语言讲话,没有人能听懂。
但他的语言是能够逐步解释成人能听懂的语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的。
魔王语言解释 数据结构
#include<stdio.h>#include<malloc.h>#include<string.h>typedef struct sqstack{char *base;char *top;int size;}zhan;typedef struct qnode{char data;struct qnode *next;}qnode,*queptr;typedef struct link{queptr front;queptr rear;}dl;void DA(char A[]){printf("A的值为:");scanf("%s",A);printf("\n");}void DB(char B[],char A[]){int i=0,j=0,k=strlen(A);char C[100];printf("B关于A的规则:");scanf("%s",C);for(i=0;i<100;i++)B[i]='\0';i=0;while(C[j]!='\0'){if(C[j]=='A'){for(int l=0;l<k;l++){B[i]=A[l];i++;}j++;}else{B[i]=C[j];i++;j++;}}}int shuru(dl &l){int n;char D[100];printf("\n要翻译的魔王语言为:");scanf("%s",D);n=strlen(D);l.front=l.rear=(queptr)malloc(sizeof(qnode));l.front->next=NULL;for(int i=0;i<n;i++){queptr p;p=(queptr)malloc(sizeof(qnode));p->data=D[i];p->next=NULL;l.rear->next=p;l.rear=p;}return n;}void shuchu(zhan &z){int i,m=z.size;for(i=0;i<m;i++){z.top--;printf("%c",*z.top);z.size--;}}void fanyi(dl &l,zhan &z,char B[],int n){int i,j,k=0,m;char o;m=strlen(B);z.base=(char*)malloc(n*sizeof(char));z.top=z.base;z.size=0;for(i=0;i<n;i++){queptr p;p=(queptr)malloc(sizeof(qnode));p=l.front->next;l.front->next=p->next;if(p->data=='B'){for(j=0;j<m;j++){printf("%c",B[j]);}}else if(p->data=='(') k=1;else if(p->data>='a'&&p->data<='z'){if(k){o=p->data;k=0;}else{*z.top=o;z.top++;z.size++;*z.top=p->data;z.top++;z.size++;}}else if(p->data==')'){*z.top=o;z.top++;z.size++;shuchu(z);// z.base=(char*)malloc(n*sizeof(char));// z.top=z.base;// z.size=0;}}}void main(){char A[100],B[100];int n;dl l;zhan z;DA(A);DB(B,A);n=shuru(l);printf("\n翻译的结果为:");fanyi(l,z,B,n);printf("\n");}。
魔王语言解释问题
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若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是:“天上一将魔王的语言自右至左进栈,总是处理栈顶字符。
若是开括号,则逐一出栈,将字母顺序入队列,直至闭括号出栈,并按规则要求逐一出队列再处理后入栈。
其他情形较简单,请读者思考应如何处理。
应首先实现栈和队列的基本操作。
【选作内容】(1)由于问题的特殊性,可以实现栈和队列的顺序存储空间共享。
(2)代换变量的数目不限,则在程序开始运行时首先读入一组第一种形式的规则,而不是把规则固定在程序中(第二种形式的规则只能固定在程序中)。
二、设计目的本次实习的目的在于使读者深入了解栈和队列的特性,以便在实际问题背景下灵活运用他们;同时还将巩固对这两种结构的构造方法的理解。
三、系统分析与设计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){找到各个大写字母对应的字符串.没有相应的则解释为’???’}}各模块之间调用关系:主函数模块{括号内元素入栈处理模块;排序入队模块{翻译大写处理模块;}}四、源程序代码#ifndef _SQQUEUE_H_#define _SQQUEUE_H_template <class ElemType>//声明一个类模板class SqQueue{public: //顺序类的各成员函数SqQueue(int m = 100);~SqQueue();void Clear();bool Empty() const;int Length() const;ElemType & GetHead() const;ElemType & GetLast() const;void Append(const ElemType &e);void Remove();private: //顺序类的数据成员ElemType *m_base; //基地址指针int m_front; //队头指针int m_rear; //队尾指针int m_size; //向量空间大小};//构造函数,分配m个结点的顺序空间,构造一个空的顺序队列。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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。