魔王语言解释-西电数据结构上机题

个人说明：
本博客的代码用于各位同学借鉴和学习，由于本人的水平有限，因此难免有错误之处，希望各位同学给与意见，共同进步！

魔王语言解释：

解决思路：

这是第二章的上机作业，我们就知道是用栈的知识来解决问题的，但是光用栈的话实现起来会很费劲，因此我们用队列进行辅助，栈和队列配合来完成，栈和队列的实现可以使用STL，非常的方便，但是我们学习数据结构的目的就是练习创建栈，并使用栈。这里我们还是使用自己创建的栈来解决这个问题。

从翻译规则来看：
A->sae;
B->tAdA;

可以发现这俩个字母的翻译内容是不变的，遇到A就翻译输出sae，如果遇到B可以直接翻译输出为tsaedsae,因此我们不遇到括号的时候，输出是稳定的，直接输出翻译内容就可以了，如果遇到括号，我们可以把分配进去的内容用栈和队列的特点进行处理。因此我们还需要判断一下输入的内容它的括号是不是匹配。

C 代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h> 
#define maxsize 100
//栈的顺序存储表示 
typedef struct {
    char *base, *top;
    int stacksize;
}SqStack;         
 
//单链队列--队列的链式存储表示 
typedef struct Node{
    char data;
    struct Node *next;
}Node, *Ptr;
 
typedef struct {
    Ptr front, rear;
}Link;
 
// 对栈的操作 
int InitStack (SqStack *S) 
{   //初始化栈 
    S->base = (char *)malloc(maxsize * sizeof (char));
    if (! S->base) exit(0);
    S->top = S->base;
    S->stacksize = maxsize;
    return 1;
}
 //入栈 
int Push (SqStack *S, char c)
{  
    * S->top ++ = c;
    return 1; 
}
 //出栈 
int Pop (SqStack *S,char *c)
{  
    if (S->base == S->top)  return 0;
    *c = * --S->top;
    return 1;
}
 
// 对队列的操作 
int Initline (Link *L)
{   //初始化队列 
    L->front = L->rear = (Ptr)malloc(sizeof(Node));
    if (!L->front) exit(0);
    L->front->next = NULL;
    return 1;
}
 
int inputline (Link *L, char c)
{   //入队列 
    Ptr p;
    p = (Ptr)malloc(sizeof(Node));
    if (!p) exit(0);
    p->data = c; p->next = NULL; 
    L->rear->next = p;
	L->rear = p;
    return 1;  
}
 
int outputline (Link *L, char *c)
{   //出队列 
    Ptr p;
    if (L->front == L->rear)   return 0;
    p = L->front->next;
    *c = p->data;
    L->front->next = p->next;
    if (L->rear == p) 
    L->rear = L->front;
    free(p);
    return 1;
}
  
//检查括号是否匹配的函数实现 
int kuohao (char *str)     
{    
    int sum = 0;                         
    char *p, c;
    SqStack K;
    InitStack(&K);
    for (p= str; *p; p ++)
    {
       switch(*p)
       {
           case '(':
                    Push(&K,*p);   
                    sum=sum+1;  break;
           case ')': 
                    if (K.base  == K.top) return 0;
                    Pop(&K,&c); 
                    if (c != '(')   return 0;      
                    break;
           //default :                  break;
       }
    }
   
    if (K.base == K.top && sum)
    {
       free(K.base );
       return 1;
    }
    else if (sum == 0)
        return 1; 
    else 
    {
       free(K.base );
       return 0; 
    }
} //函数结束 
 
// 最后处理 
void special (SqStack *S, SqStack *S1)
{
char ch, B[9] = "tsaedsae", A[4] = "sae";
int i = 0;
while(S1->base != S1->top){
    Pop (S1, &ch);
    switch (ch){
        case 'A': 
            for (i = ( strlen(A) - 1 ); i >= 0; -- i)
                Push(S, A[i]);
                 break;
        case 'B': 
            for (i = ( strlen(B) - 1 ); i >= 0; -- i)
                Push(S, B[i]);
                break;
    default : Push(S, ch);  break;
       }
    }  
}

int main ()
{
    int i;
    char R, T, B, str[1000] = {0};
    SqStack S, X; 
    Link temp;
    InitStack (&S);
    InitStack (&X);
    Initline (&temp);
    scanf("%s", str);
 
    if ( kuohao(str) )
    {
        for (i = ( strlen(str) - 1 ); i >= 0; -- i)
            Push(&S, str[i]);
 
        while(S.base != S.top)
        {
            Pop(&S, &R);
            if (R != ')')
               Push(&X, R);
            else if(R == ')')
            {
                while (X.base != X.top )
                {
                   Pop(&X, &T);
                   if (T != '(')
                   {
                      inputline (&temp, T);
                     B = T;
                   }
                   else   break;
                }
 
                while (temp.front->next != temp.rear)
                {
                    outputline (&temp, &T);
                    Push (&X, B);
                    Push (&X, T);
                }
 
                outputline (&temp, &T);
                Push (&X, T);
            }
        }
        special (&S, &X);
        while ( Pop(&S,&R) )
        printf ("%c", R);   
    }
    return 0;
} 

总结：

这是用栈和队列结合实现的一个程序，算是比较简单的一个程序，就是在实现的时候要注意实现的方式，还有括号匹配和括号外字符分配问题。这个问题还有其他的实现方式，希望同学们多动手多思考！