数据结构课程设计（魔王语言（c语言）的简单代码）

设计思想：此代码写的相对简单，思路易懂，用到的是栈和队列的思想，主要是对数据结构初学者起到一个参考作用；
问题描述：有一个魔王总是使用自己的一种非常精练而抽象的语言讲话,没有人能昕得懂,但他的语言是可以逐步解释成人能听懂的语言,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的

在这两种形式中,从左到右均表示解释。试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话。
[设计要求]:
用下述两条具体规则和上述规则形式(2)实现。设大写字母表示魔王语言的词汇:小写字母表示人的语言词汇:希腊字母表示可以用大写字母或小写字母代换的变量。魔王语言可含人的词汇。

完整代码如下：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_CHAR 100 //输入字符串的最大长度
#define OK 1;
#define ERROR -1;

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 init(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);

}
//队列的初始化
PSTACK init1(void)
{
PSTACK pS = (PSTACK)malloc(sizeof(STACK));
pS->rear = (PNODE)malloc(sizeof(NODE));
pS->front = pS->rear;
pS->rear->next = NULL;
return pS;
}

void Insert_Queue(PSTACK Q,ElemType e)
/* 将数据元素e插入到链队列Q的队尾 /
{
PNODE p=(PNODE)malloc(sizeof(NODE)) ;
/ 申请新结点失败，返回错误标志 /
p->data=e ; p->next=NULL ; / 形成新结点 */
Q->rear->next = p;
Q->rear = p;

}
void Delete_LinkQueue(PSTACK Q, int * x)
{
PNODE p ;
if (Q->frontQ->rear) return; /* 队空 /
p=Q->front->next ; / 取队首结点 /
* x = p->data;
Q->front->next=p->next ; / 修改队首指针 */
if (pQ->rear) Q->rear=Q->front ;
/* 当队列只有一个结点时应防止丢失队尾指针 */
free§ ;
}

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)
{
PNODE p = Q->front->next;
while§
{
printf("%c",p->data);
p = p->next;
}
printf("\n");
}

//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->nextNULL)
break;
Insert_Queue(Q,c);
}
}
//如果language[i]为‘a—z’时：
else if(language[i]>=‘a’&&language[i]<=‘z’){
/调用函数，使相应的字符进入‘处理队列’/
Insert_Queue(Q,language[i]);
}
}
printf (“队列内内容为：”);
QueueTraverse(Q);
printf ("----------判定结束----------\n\n");
}

//3.翻译‘处理队列’中的字符串
void Translate(PSTACK Q){
/遍历‘处理队列’，根据字符依次输出相应汉字/
char c;
PNODE p = Q->front->next;
while §
{
switch (p->data)
{
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;
}
}

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

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

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

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

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

return 0;

}
// B(ehnxgz)B

运行截图如下：

设计思路：