数据结构习题集之魔王语言解释

魔王语言解释

问题描述有
一个魔王总是使用自已的一种非常精练而抽象的语言讲话，没有人能听得懂。
但他的语言是可以逐步解释成人能懂的语言的，因为他的语言是由以下两种形式
的规则由人的语言逐步抽象上去的：
（1） α→β1β2…βm
（2） (θβ1β2…βm)→(θβm…β2θβ1θ)
在这两种形式中，从左到右均表示解释； 从右到左均表示抽象。
写一个魔王解释程序，将魔王的话解释成人能听懂的话。
基本要求：设大写字母表示魔王语言的词汇，小写字母表示人的词汇，希腊字母表示可以用大写字母或小写字母代换的变量。用下述两种规则和下述规则（2）实现。
(1) B→tAdA
(2) A→sae
测试数据：B(einxgz)B
B(einxgz)B=>tAdA(einxgz)tAdA=>tsaedsae(einxgz)tsaedsae
　　=> tsaedsaeezegexeneietsaedsae
字母-汉字对应表:
t d s a e z g x n i
天 在 上 一个 鹅 追 赶 下 蛋 恨

链栈结构

#ifndef SQSTACK_H_INCLUDED
#define SQSTACK_H_INCLUDED
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1

typedef   int Status;
typedef struct SNode{
     char data;
     struct SNode *next;
}SNode,*StackPtr;

typedef struct {
     StackPtr Base;
     StackPtr Top;
     int Length;
}LinkStack;

Status InitStack(LinkStack *L){
      L->Top=(StackPtr)malloc(sizeof(SNode));
      if(!L->Top)
          exit(-1);
      L->Base=L->Top;
      L->Top->next=NULL;
      L->Length=0;
      return OK;
}

Status Push(LinkStack *L,char C){
      StackPtr New=(StackPtr)malloc(sizeof(SNode));
      if(!New)
             return ERROR;
      New->next=L->Top->next;
      L->Top->next=New;
      New->data=C;
      L->Length++;
      if(L->Length==1)
          L->Base=New;
      return OK;
}

Status Pop(LinkStack *L, char *C){
      if(L->Base==L->Top)
           return ERROR;
      StackPtr Temp;
      Temp=L->Top->next;
      *C=Temp->data;
      if(Temp==L->Base)
      {
          L->Base=L->Top;
          L->Top->next=NULL;
          free(Temp);
      }
      else
      {
          L->Top->next=Temp->next;
          free(Temp);
      }
      L->Length--;
      return OK;
}

Status StackEmpty(LinkStack *L){
      if(L->Top==L->Base&&L->Length==0)
           return TRUE;
      else
          return FALSE;
}
#endif // SQSTACK_H_INCLUDED

链队列结构

#ifndef LINKQUEUE_H_INCLUDED
#define LINKQUEUE_H_INCLUDED
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

typedef   int Status;
typedef struct QNode{
     char data;
     struct QNode *next;
}QNode,*QueuePtr;

typedef struct{
     QueuePtr front;
     QueuePtr rear;
}LinkQueue;

Status InitQueue(LinkQueue *Q){
     Q->front=(QueuePtr)malloc(sizeof(QNode));
     if(!Q->front)
          exit(-1);
     Q->rear=Q->front;
     Q->front->next=NULL;
     return OK;
}

Status EnQueue(LinkQueue *Q,char e){
      QueuePtr P=(QueuePtr)malloc(sizeof(QNode));
      if(!P)
         exit(-1);
      P->data=e;
      P->next=NULL;
      Q->rear->next=P;
      Q->rear=P;
      return OK;
}

Status DeQueue(LinkQueue*Q,char *e){
      if(Q->front==Q->rear)
            return ERROR;
      QueuePtr P=Q->front->next;
      *e=P->data;
       Q->front->next=P->next;
       if(Q->rear==P)
           Q->rear=Q->front;
       free(P);
       return OK;
}

Status QueueLength(LinkQueue *Q){
       QueuePtr P=Q->front->next;
       int num=1;
       while(P->next!=NULL)
       {
           num++;
           P=P->next;
       }
       return num;
}

Status QueueEmpty(LinkQueue *Q){
      if(Q->front==Q->rear)
          return TRUE;
      else
          return  FALSE;
}

#endif // LINKQUEUE_H_INCLUDED

#include 
#include 
#include 
#include "SqStack.h"
#include "LinkQueue.h"

typedef struct {
     char A;
     char B[10];
}Rule,*Rules;
Rules R;
int N;

 typedef struct{
      char Words[40];
      int  Length;
 }Devilwords;
 Devilwords W;
 LinkStack  L;
 LinkQueue Q;

void Start(){
      scanf("%d",&N);
      getchar();
      InitStack(&L);
      InitQueue(&Q);
      return;
}

void RulesIn(){
      R=(Rules)malloc(N*sizeof(Rule));
      for(int i=0;i%s",&R[i].A,R[i].B);
        getchar();
      }
      return;
}

void  DevilSay(){
      printf("比克大魔王说凶残地说: \n");
      scanf("%s",W.Words);
      W.Length=strlen(W.Words);
      return;
}
void PreDeal(){
      int i=W.Length-1;
      while(i>=0){
        char e;
        if(W.Words[i]=='(')
        {
            Pop(&L,&e);
            char theta;
            while(1){
                Pop(&L,&theta);
                if(theta==')')
                     break;
                EnQueue(&Q,theta);
            }
            while(!QueueEmpty(&Q)){
                DeQueue(&Q,&theta);
                Push(&L,e);
                Push(&L,theta);
            }
            Push(&L,e);
        }
        else
            Push(&L,W.Words[i]);
        i--;
      }
      return;
}

void MidDeal(){
      char e;
      for(int i=0;i