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

魔王语言解释

问题描述有
一个魔王总是使用自已的一种非常精练而抽象的语言讲话，没有人能听得懂。
但他的语言是可以逐步解释成人能懂的语言的，因为他的语言是由以下两种形式
的规则由人的语言逐步抽象上去的：
（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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#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<N;i++)
      {
        scanf("%c-->%s",&R[i].A,R[i].B);
        getchar();
      }
      return;
}

void  DevilSay(){
      printf("比克大魔王说凶残地说: 
");
      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<N;i++){
           if(i==0)
           {
               while(!StackEmpty(&L))
               {
                   Pop(&L,&e);
                   if(e==R[i].A)
                   {
                       int j=0;
                       while(R[i].B[j]!='')
                       {
                           EnQueue(&Q,R[i].B[j]);
                           j++;
                       }
                   }
                   else
                     EnQueue(&Q,e);
               }
           }
           else
           {
                EnQueue(&Q,'$');
                while(1)
                {
                    DeQueue(&Q,&e);
                    if(e=='$')
                        break;
                    if(e==R[i].A)
                    {
                       int j=0;
                       while(R[i].B[j]!='')
                       {
                           EnQueue(&Q,R[i].B[j]);
                           j++;
                       }
                    }
                    else
                        EnQueue(&Q,e);
                }
           }
      }
      return;
}
void Translate(){
      char e;
      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;
              default :  printf("错误警告
");break;
          }
      }
      return;
}
int main()
{
    system("Color 0e");
    Start();
    RulesIn();
    DevilSay();
    PreDeal();
    MidDeal();
    Translate();
    return 0;
}