魔王语言解释C（可输出）

魔王语言

魔王语言解释问题

问题

1．问题描述

有一个魔王总是使用自己的一种非常精练而抽象的语言讲话，没有人能听得懂，但他的语言是可以逐步解释成人能听懂的语言，因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的：

在这两种形式中，从左到右均表示解释。请写出一个魔王语言的解释系统，把他的话解释成人能听得懂的话。

2．基本要求

用下述两条具体规则和上述规则形式（2）实现。设大写字母表示魔王语言的词汇；小写字母表示人的语言词汇；希腊字母表示可以用大写字母或小写字母代换的变量。魔王语言可含人的词汇。

（1）B->tAdA （2）A->sae

3．测试数据

B(ehnxgz)B解释成tsaedsaeezegexenehetsaedsae

若将小写字母与汉字建立下表所示的对应关系，则魔王说的话是：“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。

4．实现提示

将魔王的语言自右至左进栈，总是处理栈顶字符。若是开括号，则逐一出栈，将字母顺序入队列，直至闭括号出栈，并按规则要求逐一出队列再处理后入栈。

思路

代码

//devil language .lyb 
//version : 2020.6.10 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAX_CHAR 100 //输入字符串的最大长度

typedef int status;
typedef char ElemType;

//存放处理后的小写字母组成的字符串语言的处理队列
typedef struct Stack_Node//链栈的结点 
{
ElemType data ;
struct Stack_Node *next ;
}NODE,*PNODE;

//链栈的首尾指针 
typedef struct stack
{
PNODE front;
PNODE rear;
}STACK,*PSTACK;

//栈初始化
PNODE initstack(void)
{
PNODE s = (PNODE)malloc(sizeof(NODE));
s->next = NULL;
return s;
}
//压栈
void push(PNODE s,ElemType x)
{
PNODE p = (PNODE)malloc(sizeof(NODE));
p->data = x;
p->next = s->next;
s->next = p;
}
//出栈
ElemType pop(PNODE s,ElemType *x)
{
	PNODE p = s->next;
	*x = p->data;
	s->next = p->next;
	free(p); 
	return (*x);

}

//队列的初始化
/*void initque(STACK pS)
{
pS.front = pS.rear =(NODE*)malloc(sizeof(NODE));
pS.front = NULL;
}*/
PSTACK initque(void)
{
PSTACK pS = (PSTACK)malloc(sizeof(STACK));
pS->rear = (PNODE)malloc(sizeof(NODE));
pS->front = pS->rear;
pS->rear->next = NULL;
return pS;
}
bool isEmpty(PSTACK Q)
{
	if(Q->front==Q->rear) return true;
	else return false;
}

void Insert_Queue(PSTACK Q,ElemType e)
{
PNODE p=(PNODE)malloc(sizeof(NODE)) ;
p->data=e ; 
p->next=NULL ;
/* 将数据元素e插入到链队列Q的队尾 /
{

/ 申请新结点失败，返回错误标志 /
 / 形成新结点 */
 Q->rear->next = p;
Q->rear = p;

}
void Delete_LinkQueue(PSTACK Q, int * x)
{
PNODE p ;
if (Q->front==Q->rear) return ; /* 队空 /

if (p==Q->rear) Q->rear=Q->front ;
/* 当队列只有一个结点时应防止丢失队尾指针 */
free(p) ;
}

void importA (PSTACK Q) {
Insert_Queue(Q,'s');
Insert_Queue(Q,'a');
Insert_Queue(Q,'e');
}

void importB (PSTACK Q) {
Insert_Queue(Q,'t');
importA (Q);
Insert_Queue(Q,'d');
importA (Q);
}

//遍历队列
void QueueTraverse(PSTACK Q)
{
//int i = Q->front;
PNODE p = Q->front;
while(p!=Q->rear )
{
printf("%c",p->data);
p = p->next;
}
printf("\n");

return;//重中之重，只差一个返回值 
}

//1.输入初始语言并获取长度
void GetLanguage(char *language,int *length){
printf("请输入魔王的语言:");
gets(language);
*length = strlen(language);
printf("您输入的魔王语言为:");
int i;
for(i = 0;i<*length;i++){
printf("%c ",language[i]);
}
printf("\n该魔王语言的长度为：%d\n\n",*length);
}

//2.分情况处理原始字符
void Transformation(char *language,int *length,PNODE S,PSTACK Q){
printf ("----------判定开始----------\n");
int i;
char c;
for (i=0;i<*length;i++){
//如果language[i]为‘A’或‘B’时：
if(language[i]=='A'||language[i]=='B'){
//调用函数，使相应的字符进入‘处理队列’/
if (language[i]=='A') {
importA(Q);
}
if (language[i]=='B'){
importB(Q);
}
}
//如果language[i]为‘（’时：
if(language[i]=='('){
//调用函数，使后续的字符进入‘处理栈’，并在遇到“）”时元素出栈进入‘处理队列’并返回/
char c1 = language[i+1];
i++;
do
{
push(S,language[i]);
++i;
}while(language[i]!=')');
while(S->next!=NULL)
{
char c = pop(S,&c);
Insert_Queue(Q,c1);
if (S->next==NULL)
break;
Insert_Queue(Q,c);
}
}
//如果language[i]为‘a—z’时：
else if(language[i]>='a'&&language[i]<='z'){
//调用函数，使相应的字符进入‘处理队列’/
Insert_Queue(Q,language[i]);
}
}
printf ("The content of the quene:");
QueueTraverse(Q);
printf ("----------ALL END----------\n\n");
}

//3.翻译‘处理队列’中的字符串
void Translate(PSTACK Q){
//遍历'处理队列’，根据字符依次输出相应汉字/
char c;
PNODE p = Q->front->next;
while (!isEmpty(Q))   //遍历队列的条件 队列不空  之前错误 p!=p->next
{
switch (p->data)//switch case 的缺憾 
{
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;
default: printf("ERROR ");
}
p = p->next;
}
return; 
}

//调用函数，使相应的字符进入'处理队列'/

int main(){
printf("-----------------------\n");
printf(" 魔王语言解释\n");
printf("-----------------------\n");
PNODE S = initstack();
PSTACK Q =  initque();	
char language[MAX_CHAR]; //存放原始‘魔王语言’/
int length=0; //取初始‘魔王语言’的长度/
//	QUEUE Q; /创建‘处理队列’，存放初步处理后的‘魔王语言’/
//	initQueue(&Q); /初始化‘处理队列’/


GetLanguage(language,&length);//1.利用‘string’输入"魔王语言"，保存至‘language[MAX_CHAR]’字符串内并获取字符串长度

Transformation(language,&length,S,Q);//2.将‘language[MAX_CHAR]’中的字符依次判断，传输至‘A、B函数’、‘处理栈’，转换为小写字母储存至‘处理队列’


Translate(Q);//3.将‘处理队列’中的字符串依次判断输出相应汉字
return 0;
}

结果

缺憾

117行改正之后可正常输出，但是return 3221225477

有所缺憾，欢迎各位大牛指正