Welcome
Question:
一个魔王总是使用自已的一种非常精练而抽象的语言讲话，没有人能听得懂。
但他的语言是可以逐步解释成人能懂的语言的，因为他的语言是由以下两种形式
的规则由人的语言逐步抽象上去的：
（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
算法分析
1.定义一个字符数组(demon_init)保存原始的魔王语言数据。
2.将原始数据中的A，B消去(通过函数purify实现)，并储存在队列(demon)中。
3.对括号中的数据展开(函数change实现)，同时打印字符。
change函数讲解：
-
first：当队列demon非空，出队头字符（a）。
-
second：若a为小写字母，则打印；若a为(，则进行括号展开（unfold函数实现）；其余情况为非法输入，结束。
-
third：a==’(’ => 括号展开unfold函数：初始化栈（brackets），并压入 ( 。
逐个取队首（demon）字符（a）压入栈（brackets）中，直至取到 ) 停止入栈。=>进入fourth过程。
压栈过程中保持首字符指针（char *p）指向最内层括号首字符。 -
fourth：a==’)’ => 停止压栈，建新队列（expand）处理最内层括号数据。
逐个出栈（s），入队列首字符（*p），入队列s，直到出栈至首字符上一个停止，入队列首字符，出栈首字符和 ( 。
出队列（expand）中所有字符至栈（brackets）中。重新使得p指向次外层括号首字符。 -
fifth：重复third和fourth过程，直至栈（brackets）空，遍历打印队列（expand）中元素。括号中的字符处理结束，返回second过程，直至队列（demon）空。
-
finish！
头文件引用
基本IO操作（base.h)
#include <string.h>
#include <ctype.h>
#include <malloc.h> // malloc()等
#include <limits.h> // INT_MAX等
#include <stdio.h> // EOF(=^Z或F6),NULL
#include <stdlib.h> // atoi()
#include <math.h> // floor(),ceil(),abs()
#include <iostream> // cout,cin
#include <cstdlib> //exit()
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE
队列基本操作(queue.h)
//循环队列的基本操作头文件
#ifndef _QUEUE_H_
#define _QUEUE_H_
#include "base.h"
#define MAXQSIZE 100 // 最大队列长度(对于循环队列，最大队列长度要减1)
//循环队列节点结构
struct SqQueue
{
QElemType *base; // 初始化的动态分配存储空间
int front; // 头指针,若队列不空,指向队列头元素
int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置
};
//基本操作声明//
//构造一个空队列Q
Status InitQueue(SqQueue &Q);
//销毁队列Q,Q不再存在
Status DestroyQueue(SqQueue &Q);
// 将Q清为空队列
Status ClearQueue(SqQueue &Q);
//若队列Q为空队列，则返回TURE，否则返回FALSE
Status QueueEmpty(SqQueue Q);
//返回Q的元素个数，即为队列的长度
int QueueLength(SqQueue Q);
//若队列不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR
Status GetHead(SqQueue Q, QElemType &e);
//插入元素e为Q的新的队尾元素
Status EnQueue(SqQueue &Q, QElemType e);
//若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR
Status DeQueue(SqQueue &Q, QElemType &e);
//从队头到队尾依次对队列Q中每个元素打印。若打印失败，则操作失败。
Status QueueTraverse(SqQueue Q);
//---------基本操作的算法描述----------
Status InitQueue(SqQueue &Q)
{
Q.base = (QElemType *)malloc(MAXQSIZE * sizeof(QElemType));
if (!Q.base) //若错误，则退出
exit(ERROR);
Q.front = Q.rear = 0;
return OK;
}
Status DestroyQueue(SqQueue &Q)
{
if (Q.base)
free(Q.base);
Q.base = NULL;
Q.front = Q.rear = 0;
return OK;
}
Status ClearQueue(SqQueue &Q)
{
Q.front = Q.rear = 0;
return OK;
}
Status QueueEmpty(SqQueue Q)
{
if (Q.front == Q.rear)
return TRUE;
else
return FALSE;
}
int QueueLength(SqQueue Q)
{
return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}
Status GetHead(SqQueue Q, QElemType &e)
{
if (Q.front == Q.rear) //队空结束
return ERROR;
e = *(Q.base + Q.front);
return OK;
}
Status EnQueue(SqQueue &Q, QElemType e)
{
if ((Q.rear + 1) % MAXQSIZE == Q.front) //队列满则结束
return ERROR;
Q.base[Q.rear] = e;
Q.rear = (Q.rear + 1) % MAXQSIZE;
return OK;
}
Status DeQueue(SqQueue &Q, QElemType &e)
{
if (Q.front == Q.rear) //队空结束
return ERROR;
e = Q.base[Q.front];
Q.front = (Q.front + 1) % MAXQSIZE;
return OK;
}
Status QueueTraverse(SqQueue Q)
{
int i;
i = Q.front;
while (i != Q.rear)
{
printf("%c", *(Q.base + i));
i = (i + 1) % MAXQSIZE;
}
return OK;
}
#endif
栈基本操作(stack.h)
//栈的基本操作头文件(线性栈)
#ifndef _STACK_H_
#define _STACK_H_
#include "base.h"
#define STACK_INIT_SIZE 100 //储存空间初始分配量
#define STACKINCREMENT 10 //存储空间分配增量
//顺序栈节点结构
typedef struct Stack
{
SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL
SElemType *top; // 栈顶指针(指向栈顶元素的上一个区域)
int stacksize; // 当前已分配的存储空间，以元素为单位
} SqStack;
//基本操作声明//
// 构造一个空栈S
Status InitStack(SqStack &S);
// 销毁栈S，S不再存在
Status DestroyStack(SqStack &S);
// 把S置为空栈
Status ClearStack(SqStack &S);
// 若栈S为空栈，则返回TRUE，否则返回FALSE
Status StackEmpty(SqStack S);
// 返回S的元素个数，即栈的长度
int StackLength(SqStack S);
// 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
Status GetTop(SqStack S, SElemType &e);
// 插入元素e为新的栈顶元素
Status Push(SqStack &S, SElemType e);
// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
Status Pop(SqStack &S, SElemType &e);
// 从栈底到栈顶依次对栈中每个元素调用函数visit()。一旦visit()失败，则操作失败
Status StackTraverse(SqStack S, Status (*visit)(SElemType));
//遍历visit函数，打印
Status visit(SElemType c);
//---------基本操作的算法描述------------
Status InitStack(SqStack &S)
{
S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
if (!S.base)
exit(ERROR); //分配失败退出
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
return OK;
}
Status DestroyStack(SqStack &S)
{
free(S.base);
S.base = NULL;
S.top = NULL;
S.stacksize = 0;
return OK;
}
Status ClearStack(SqStack &S)
{
S.top = S.base;
return OK;
}
Status StackEmpty(SqStack S)
{
if (S.top == S.base)
return TRUE;
else
return FALSE;
}
int StackLength(SqStack S)
{
return S.top - S.base;
}
Status GetTop(SqStack S, SElemType &e)
{
if (S.top > S.base)
{
e = *(S.top - 1);
return OK;
}
else
return ERROR;
}
Status Push(SqStack &S, SElemType e)
{
//栈满，动态分配空间
if (S.top - S.base >= S.stacksize)
{
S.base = (SElemType *)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
if (!S.base) //动态分配失败，退出
exit(ERROR);
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
/*
S.top=e;
*(S.top)++;
*/
*(S.top)++ = e; //先赋值，再自加
return OK;
}
Status Pop(SqStack &S, SElemType &e)
{
if (S.top == S.base) //栈空结束
return ERROR;
/*
S.top--;
e=*S.top;
*/
e = *(--S.top); //先自减，在赋值
return OK;
}
Status StackTraverse(SqStack S, Status (*visit)(SElemType))
{
while (S.top > S.base)
visit(*S.base++);
printf("/n");
return OK;
}
Status visit(SElemType c)
{
printf("%c", c);
}
#endif
主文件
//魔王语言问题
/*
B->tAdA->tseadsea
A->sae
*/
typedef char SElemType;
typedef char QElemType;
#include <iostream>
using namespace std;
#include "base.h"
#include "stack.h"
#include "queue.h"
//----------函数声明----------//
//将原始字符串中的A，B转换
int purify(SqQueue &demon, char *init);
//处理数据，并同时打印出来
int change(SqQueue demon);
//处理大括号内的元素，完成后打印
int unfold(SqQueue &demon);
//------------main-------------//
int main()
{
SqQueue demon; //储存已处理字符串
char demon_init[100]; //储存原始魔王语言
cout << "Please input the demon language:" << endl; //提示
cin >> demon_init; //输入原始魔王语言
// 初始化队列和栈
InitQueue(demon);
cout << "Human language is:" << endl; //提示
purify(demon, demon_init);
change(demon);
printf("\n");
return 0;
}
//----------函数实现----------//
int purify(SqQueue &demon, char *init)
{
char c; //代替init[i]
int len_init = strlen(init);
for (int i = 0; i < len_init; i++)
{
c = init[i];
if (c == 'A')
{
EnQueue(demon, 's');
EnQueue(demon, 'a');
EnQueue(demon, 'e');
}
else if (c == 'B')
{
EnQueue(demon, 't');
EnQueue(demon, 's');
EnQueue(demon, 'a');
EnQueue(demon, 'e');
EnQueue(demon, 'd');
EnQueue(demon, 's');
EnQueue(demon, 'a');
EnQueue(demon, 'e');
}
else if (c >= 'a' && c <= 'z' || c == '(' || c == ')')
EnQueue(demon, c);
else
{
printf("!!!ERROR,Please Reenter!");
break;
}
}
}
int change(SqQueue demon)
{
char a;
while (!QueueEmpty(demon))
{
DeQueue(demon, a);
if (a <= 'z' && a >= 'a')
printf("%c", a);
else if (a == '(')
{
unfold(demon);
}
else
{
printf("Error!");
break;
}
}
}
int unfold(SqQueue &demon)
{
char a; //储存队列队首元素
char s; //储存小括号非首字符元素
Stack brackets; //储存大括号内元素并进行处理
InitStack(brackets);
Push(brackets, '('); //使得栈非空
SElemType *p = brackets.top; //指向第一个大括号的首字符
SqQueue expand; //储存展开小括号中的元素
InitQueue(expand);
char e; //储存小括号展开队列队首元素
while (!StackEmpty(brackets))
{
DeQueue(demon, a);
if (a != ')')
{
Push(brackets, a);
if (a == '(') //保持p指向最小括号首字符
p = brackets.top;
}
else //转换小括号内的字符串
{
while (brackets.top != (p + 1))
{
Pop(brackets, s);
EnQueue(expand, *p);
EnQueue(expand, s);
}
Pop(brackets, s);
EnQueue(expand, *p);
brackets.top--; //消去'('
if (!StackEmpty(brackets))
while (!QueueEmpty(expand))
{
DeQueue(expand, e);
Push(brackets, e);
}
else
{
break;
}
while (*p != '(') //使得p指向下一个'('
p--;
p++; //使得p指向下一个小括号的首字符
}
}
//输出展开大括号后的字符串
if (StackEmpty(brackets))
QueueTraverse(expand);
}
//-----------finish------------//
END
希望对你能有所帮助，如有错误，请指教～
原创，转载请说明出处！
扫一扫
2362
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
