beelzebublang.h

魔王语言解释程序 请大家多多支持 数据结构实验

#include <iostream>
#include <string>
#include <utility>//使用pair类型
#include <fstream>//用于文件操作的头文件
using namespace std;

//---------------抽象数据类型顺序栈的定义------------------//
#define STACK_INIT_SIZE 100
#define STACK_INCREMENT 10
typedef char SElemType,QElemType;
typedef struct {
  SElemType  *base;
  SElemType  *top;
  int StackSize;
}SqStack;

//---------------抽象数据类型循环队的定义------------------//
#define MAXQSIZE 100
typedef struct {
  QElemType *base;
  int front;
  int rear;
}SqQueue;

//产生式
string geneformula1 = "B:tAdA";
string geneformula2 = "A:sae";
string transLang;

pair<char,string> code[24] ;//密码对<字符,中文>

void InitProg()
{
   ifstream infile( "code.txt" );
   if ( !infile ) {
        cerr << "不能打开code.txt!,程序退出. ";        
        exit;
   }
   string line;
   int j = 0;
   while(getline(infile,line)){
         code[j].first = line[0];
		 for(int i = 2;i<line.size();i++)
			 code[j].second.push_back(line[i]); 
		 j++;
   }
}

void TransChinese(string s)
{//接受一个字符串,根据code.txt,将s翻译成为中文串,并输出到控制台
	for(int i = 0; i<s.size(); i++){
	//'a'的ASC码是97
		cout<<code[s[i]-97].second;
	}

}

//---------------------顺序栈的接口函数声明-----------------------//
//构造一个空栈
bool InitStack(SqStack &S);

//销毁栈,释放栈所占内存空间
void DestroyStack(SqStack &S);

//把S置为空栈
bool ClearStack(SqStack &S);

//若栈S为空栈,返回true,否则返回false
bool StackEmpty(SqStack &S);

//返回栈S的元素个数,即栈的长度
int StackLength(SqStack &S);

//若栈不空,则用e返回S的栈顶元素,并返回ok;否则返回error
bool GetTop(SqStack &S,SElemType &e);

//插入新元素e为新的栈顶元素
bool Push(SqStack &S,SElemType e);

//若栈不空,删除S的栈顶元素,并用e返回其值,并返回true,否则返回false
bool Pop(SqStack &S,SElemType& e);

//---------------------循环队的接口函数声明-----------------------//
//初始化循环队
bool InitQueue(SqQueue &Q);

//返回Q的元素个数,即队列的长度
int QueueLength(SqQueue &Q);

//插入新元素e为Q的新队尾元素
bool EnQueue(SqQueue &Q, QElemType e);

//若队列不空,则删除Q的队头元素,用e返回其值,并返回true,否则返回false;
bool DeQueue(SqQueue &Q, QElemType &e);

//-----------接口函数的实现部分-------------------//
bool InitStack(SqStack &S)
{//构造一个空栈
	S.base = new SElemType[STACK_INIT_SIZE];
	if(!S.base) return false;
	S.top = S.base;
	S.StackSize = STACK_INIT_SIZE;
	return true;
}//InitStack


void DestroyStack(SqStack &S)
{//销毁栈,释放栈所占内存空间
	if( S.base ) delete []S.base;
}//DestroyStack


bool ClearStack(SqStack &S)
{//把S置为空栈
    if(!S.base) return false;
	S.top = S.base;
	return true;
}//ClearStack


bool StackEmpty(SqStack &S)
{//若栈S为空栈,返回true,否则返回false
	if( S.base == S.top ) return true;
	else return false;
}//StackEmpty


int StackLength(SqStack &S)
{//返回栈S的元素个数,即栈的长度
	return S.top - S.base;
}//StackLength


bool GetTop(SqStack &S, SElemType &e)
{//若栈不空,则用e返回S的栈顶元素,并返回ok;否则返回error
	if ( S.top == S.base ) return false;
	e = *(S.top - 1);//栈顶指针总是指向栈顶元素的下一个存储单元的
	return true;
}//GetTop


bool Push(SqStack &S,SElemType e)
{//插入新元素e为新的栈顶元素
	if((S.top - S.base)== S.StackSize){//栈满,追加存储空间
		S.base = new(S.top) SElemType[STACK_INCREMENT];	
		if (S.base) return false;
		S.top = S.base + S.StackSize;
		S.StackSize += STACK_INCREMENT;
	}
	*S.top++ = e;
	return true;
}//Push


bool Pop(SqStack &S,SElemType& e)
{//若栈不空,删除S的栈顶元素,并用e返回其值,并返回true,否则返回false
	if( S.top == S.base ) return false;
	e = *--S.top;
	return true;
}//Pop


//---------------------循环队的接口函数实现-----------------------//

bool InitQueue(SqQueue &Q)
{//初始化循环队
	Q.base = new QElemType[MAXQSIZE];
	if(!Q.base) return false;
	Q.front = Q.rear = 0;
	return true;
}//InitQueue


int QueueLength(SqQueue &Q)
{//返回Q的元素个数,即队列的长度
	return (Q.rear - Q.front + MAXQSIZE)% MAXQSIZE;
}//QueueLength


bool EnQueue(SqQueue &Q, QElemType e)
{//插入新元素e为Q的新队尾元素
	if((Q.rear+1)%MAXQSIZE == Q.front) return false;
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear+1)%MAXQSIZE;
	return true;
}//EnQueue


bool DeQueue(SqQueue &Q, QElemType &e)
{//若队列不空,则删除Q的队头元素,用e返回其值,并返回true,否则返回false;
	if(Q.front == Q.rear) return false;
	e = Q.base[Q.front];
	Q.front = (Q.front+1)%MAXQSIZE;
	return true;
}//DeQueue