魔王语言C语言 使用头文件封装 链表链栈顺序队列的基本操作

1、抽象数据类型的定义和说明:

a) 链栈类型
由于沿用了链表，因此此处列出修改后的链表抽象数据类型
SElemType：数据结点，内含一个char型的数据zi;
SqStack：栈，包含存储空间基址elem、指向下一结点的指针next、当前长度length、当前分配的存储容量listsize。

b) 顺序队列类型
SqQueue：类型为QElemType的数组data[MAXSIZE]（MAXSIZE为200）、头指针int front_point、尾指针int rear_point

2、程序包含的模块

链表的基本操作

//将结点封装起来，以后可以修改结点内的元素个数，复用性高
typedef struct ElemType
{
	char zi;
}*LinkNode, ElemType;//数据结点

typedef struct LinkList
{
	struct ElemType* elem; // 存储空间基址
	struct LinkList* next;//指向下一结点的指针
	int length; // 当前长度
	int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)
}SqList, *Link;//链表

Status InitList(SqList* L);// 构造一个空的顺序线性表
Status DestroyList(SqList* L);// 销毁顺序线性表L
Status ClearList(SqList* L);// 将L重置为空表
Status ListEmpty(SqList L);// 链表判空
int ListLength(SqList L);// 返回链表的结点个数
Status GetElem(SqList L, int i, ElemType* e);//用e返回L中第i个数据元素的值
int* LocateElem(SqList L, ElemType e, Status(*compare)(ElemType *e, ElemType *e0));//元素定位
Status PriorElem(SqList L, ElemType* cur_e, ElemType* pre_e);//返回前驱结点
Status NextElem(SqList L, ElemType* cur_e, ElemType* next_e);//返回后继结点
//Status ListInsert(SqList* L, int *i, ElemType e);//在L中第i个位置之前插入新的数据元素e
Status ListInsert(SqList* L, int i, ElemType e);//在L中第i个位置之前插入新的数据元素e
Status ListDelete(SqList* L, int i, ElemType* e);// 删除L的第i个数据元素，并用e返回其值
Status ListTraverse(SqList L, void(*vi)(ElemType*));// 依次对L的每个数据元素调用函数vi()。一旦vi()失败，则操作失败
SqList Reverse(SqList *L);//头插法反转链表，返回新的链表

链栈的基本操作

typedef LinkList SqStack;//链栈
typedef ElemType SElemType;

Status InitStack(SqStack *S);//初始化栈
Status DestroyStack(SqStack* S);//销毁栈
Status ClearSqStack(SqStack* S);//清空栈
Status SqStackEmpty(SqStack S);//判断栈是否为空
int SqStackLength(SqStack S);//获取栈的长度
Status GetTop(SqStack S,SElemType* e);//获取栈顶元素，不改变栈的结构
Status Push(SqStack *S,SElemType e);//压栈
Status Pop(SqStack *S,SElemType *e);//弹栈
void showStack(SqStack S);//打印栈中的元素

顺序队列的基本操作

Status InitQueue(SqQueue *sQ);//初始化队列
Status ClearQueue(SqQueue *Q);//清空队列
Status QueueEmpty(SqQueue Q);//判断队列是否为空
int QueueLength(SqQueue Q);//返回队列的元素个数
Status GetHead(SqQueue Q, QElemType *e);//获取队尾即将出队的元素
Status EnQueue(SqQueue *Q, QElemType e);//入队
Status DeQueue(SqQueue *Q, QElemType *e);//出队
Status QueueTraverse(SqQueue Q);//遍历队

魔王语言基本操作

char** input_rule();//大写与小写字母之间的规则
char** input_rule2();//小写与人类语言的规则
SqStack delkuohao(SqQueue Q1);//处理括号内的字符串
Status is_big(char tempch,char** rule);//判断是否是大写字母
SqQueue trans_to_little(SqStack S_ori,char** rule);//按照规则将大写字母换成对应的小写字母
void trans_to_human(SqQueue Qfinally,char** rule2);//将小写字母换成人类语言

3、 各模块间的调用关系

4、流程图
a) 去括号函数

b) 主函数

5、代码实现
a)、文件结构

b)、源码部分

//避免头文件被多次包含
#pragma once
#include "lianbiao.h"

typedef LinkList SqStack;//链栈
typedef ElemType SElemType;

Status InitStack(SqStack *S);//初始化栈
Status DestroyStack(SqStack* S);//销毁栈
Status ClearSqStack(SqStack* S);//清空栈
Status SqStackEmpty(SqStack S);//判断栈是否为空
int SqStackLength(SqStack S);//获取栈的长度
Status GetTop(SqStack S,SElemType* e);//获取栈顶元素，不改变栈的结构
Status Push(SqStack *S,SElemType e);//压栈
Status Pop(SqStack *S,SElemType *e);//弹栈
void showStack(SqStack S);//打印栈中的元素

#include "zhan.h"

//初始化栈
Status InitStack(SqStack *S)
{
    return InitList(S);
}
//销毁栈
Status DestroyStack(SqStack* S)
{
    return DestroyList(S);
}
//清空栈
Status ClearSqStack(SqStack* S)
{
    return ClearList(S);
}
//判断栈是否为空
Status SqStackEmpty(SqStack S)
{
    return ListEmpty(S);
}
//获取栈的长度
int SqStackLength(SqStack S)
{
    return ListLength(S);
}
//获取栈顶元素，不改变栈的结构
Status GetTop(SqStack S,SElemType* e)
{
    return GetElem(S,ListLength(S), e);
}
//压栈
Status Push(SqStack *S,SElemType e)
{
    return ListInsert(S,ListLength(*S)+1, e);
}
//弹栈
Status Pop(SqStack *S,SElemType *e)
{
    return ListDelete(S,ListLength(*S), e);
}
//打印栈中的元素
void showStack(SqStack S)
{
    while(!SqStackEmpty(S))
    {
        SElemType e0;
        Pop(&S,&e0);
        printf("%c ",e0.zi);
    }
    printf("\n");
}

//避免头文件被多次包含
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<malloc.h>
#include<ctype.h>
#include<limits.h>
#include<io.h>
#include<process.h>
// 函数结果状态代码
#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

// c2-1.h 线性表的动态分配顺序存储结构
#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量
#define LISTINCREMENT 2 // 线性表存储空间的分配增量
#define INIT_LEN sizeof(ElemType)*LIST_INIT_SIZE// 线性表存储空间的初始分配量的内存大小
#define EXPAND_LEN sizeof(ElemType)*LISTINCREMENT// 线性表存储空间的分配增量的内存大小
//将结点封装起来，以后可以修改结点内的元素个数，复用性高
typedef struct ElemType
{
	char zi;
}*LinkNode, ElemType;//数据结点

typedef struct LinkList
{
	struct ElemType* elem; // 存储空间基址
	struct LinkList* next;//指向下一结点的指针
	int length; // 当前长度
	int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)
}SqList, *Link;//链表

Status InitList(SqList* L);// 构造一个空的顺序线性表
Status DestroyList(SqList* L);// 销毁顺序线性表L
Status ClearList(SqList* L);// 将L重置为空表
Status ListEmpty(SqList L);// 链表判空
int ListLength(SqList L);// 返回链表的结点个数
Status GetElem(SqList L, int i, ElemType* e);//用e返回L中第i个数据元素的值
int* LocateElem(SqList L, ElemType e, Status(*compare)(ElemType *e, ElemType *e0));//元素定位
Status PriorElem(SqList L, ElemType* cur_e, ElemType* pre_e);//返回前驱结点
Status NextElem(SqList L, ElemType* cur_e, ElemType* next_e);//返回后继结点
//Status ListInsert(SqList* L, int *i, ElemType e);//在L中第i个位置之前插入新的数据元素e
Status ListInsert(SqList* L, int i, ElemType e);//在L中第i个位置之前插入新的数据元素e
Status ListDelete(SqList* L, int i, ElemType* e);// 删除L的第i个数据元素，并用e返回其值
Status ListTraverse(SqList L, void(*vi)(ElemType*));// 依次对L的每个数据元素调用函数vi()。一旦vi()失败，则操作失败
SqList Reverse(SqList *L);//头插法反转链表，返回新的链表

#include "lianbiao.h"

// 构造一个空的顺序线性表
Status InitList(SqList* L)
{
    (*L).elem = (ElemType*)malloc(INIT_LEN);
    if (!(*L).elem)
        exit(OVERFLOW); // 存储分配失败
    (*L).length = 0; // 空表长度为0
    (*L).listsize = LIST_INIT_SIZE; // 初始存储容量
    return OK;
}
// 销毁顺序线性表L
Status DestroyList(SqList* L)
{
    free((*L).elem);
    (*L).elem = NULL;
    (*L).length = 0;
    (*L).listsize = 0;
    return OK;
}
// 将L重置为空表
Status ClearList(SqList* L)
{
    (*L).length = 0;
    return OK;
}
/* 链表判空
   若L为空表，则返回TRUE，否则返回FALSE*/
Status ListEmpty(SqList L)
{
    if (L.length == 0)
        return TRUE;
    else
        return FALSE;
}
// 返回链表的结点个数
int ListLength(SqList L)
{
    return L.length;
}
//用e返回L中第i个数据元素的值
Status GetElem(SqList L, int i, ElemType* e)
{
    if (i<1 || i>L.length)
        exit(ERROR);
    *e = *(L.elem + i - 1);
    return OK;
}
//元素定位
int* LocateElem(SqList L, ElemType e, Status(*compare)(ElemType *e, ElemType *e0))
{ // 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(具体的返回值根据重写的规则定)
  // 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序（位序从1开始）。
  //           若这样的数据元素不存在，则返回值为0。
    ElemType* p = L.elem;// p的初值为第1个元素的存储位置
    int *i = (int *)malloc(sizeof(int *)*2);
    if(i == NULL)
        return ERROR;
    // i[0]表示第1个元素的位序,i[1]为0表示不对该数据做特殊操作，为1则将系数相加
    i[0] = 0;i[1] = 0;
    while (i[0] <= L.length && (*compare)(p, &e))
    {
        ++i[0];
        i[1] = 0;
        if((*compare)(p, &e) == TRUE)//指数较小
            return i;
        if((*compare)(p, &e) == -1)//如果检测的指数相同，i[1]调整为1
        {
            i[1] = 1;
            return i;
        }
        p++;
    }

    if (i[0] <= L.length + 1)//+1表示允许在链表尾部添加元素
        return i;
    else
    {
        i[0] = -1;//表示没找到
        return i;
    }

}
// 若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义
//这里是不是前驱是根据地址是否相同来判断的，有时候需要根据元素的值来判断，需要重写函数
Status PriorElem(SqList L, ElemType* cur_e, ElemType* pre_e)
{
    int i = 2;
    ElemType* p = L.elem + 1;
    while (i <= L.length && (p != cur_e))//若cur_e是L的第一个数据元素，则他们地址相同
    {
        p++;
        i++;
    }
    if (i > L.length)
        return INFEASIBLE;
    else
    {
        *pre_e = *--p;
        return OK;
    }
}
// 若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， 否则操作失败，next_e无定义
//这里是不是后继是根据地址是否相同来判断的，有时候需要根据元素的值来判断，需要重写函数
Status NextElem(SqList L, ElemType* cur_e, ElemType* next_e)
{
    int i = 1;
    ElemType* p = L.elem;
    while (i < L.length && p != cur_e)
    {
        i++;
        p++;
    }
    if (i == L.length)//cur_e不是L的数据元素
        return INFEASIBLE;
    else
    {
        //能够运行到这里，代表已经找到cur_e
        *next_e = *++p;//指针向后挪一位，返回cur_e的后继节点
        return OK;
    }
}

Status ListInsert(SqList *L,int i,ElemType e)
 { // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1
   // 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
   ElemType *newbase,*q,*p;
   if(i<1||i>(*L).length+1) // i值不合法
     return ERROR;
   if((*L).length>=(*L).listsize) // 当前存储空间已满,增加分配
   {
     newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
     if(!newbase)
       exit(OVERFLOW); // 存储分配失败
     (*L).elem=newbase; // 新基址
     (*L).listsize+=LISTINCREMENT; // 增加存储容量
   }
   q=(*L).elem+i-1; // q为插入位置
   for (p = &(*L).elem[(*L).length - 1]; p >= q; p--)
        *(p + 1) = *p;// 插入位置及之后的元素右移
   *q=e; // 插入e
   ++(*L).length; // 表长增1
   return OK;
 }

// 删除L的第i个数据元素，并用e返回其值，L的长度减1
Status ListDelete(SqList* L, int i, ElemType* e)
{
    ElemType* p, * q;
    if (i<1 || i>(*L).length) // i值不合法
        return ERROR;
    p = (*L).elem + i - 1; // p为被删除元素的位置
    *e = *p; // 被删除元素的值赋给e
    q = (*L).elem + (*L).length - 1; // 表尾元素的位置
    for (++p; p <= q; ++p) // 被删除元素之后的元素左移
        *(p - 1) = *p;
    (*L).length--; // 表长减1
    return OK;
}
// 依次对L的每个数据元素调用函数vi()。一旦vi()失败，则操作失败
Status ListTraverse(SqList L, void(*vi)(ElemType*))
{
    ElemType* p;
    int i;
    p = L.elem;
    for (i = 1; i <= L.length; i++)
        vi(p++);
    printf("\n");
    return OK;
}

//头插法反转链表
SqList Reverse(SqList *L)
{
    SqList newL;//反转过后的链表
    ElemType *e = L->elem;//原来的链表的数据元素基址
    int i = 0, k = ListLength(*L);
    InitList(&newL);
    while(i<k)
    {
        ListInsert(&newL,1,*e);//头插法，放在第一个位置
        i++;
        e++;
    }
    return newL;
}

//避免头文件被多次包含
#pragma once
#include "lianbiao.h"

#define MAXSIZE 200 //初始容量

typedef char QElemType;//定义数据类型

//循环队列的顺序存储结构
typedef struct{
	QElemType data[MAXSIZE];//类型为QElemType的数组
	int front_point; //头指针
	int rear_point;//尾指针，队列非空时，指向队尾元素的下一个位置
}SqQueue;

Status InitQueue(SqQueue *sQ);//初始化队列
Status ClearQueue(SqQueue *Q);//清空队列
Status QueueEmpty(SqQueue Q);//判断队列是否为空
int QueueLength(SqQueue Q);//返回队列的元素个数
Status GetHead(SqQueue Q, QElemType *e);//获取队尾即将出队的元素
Status EnQueue(SqQueue *Q, QElemType e);//入队
Status DeQueue(SqQueue *Q, QElemType *e);//出队
Status QueueTraverse(SqQueue Q);//遍历队

#include "diulie.h"

//初始化空队列
Status InitQueue(SqQueue *sQ){
	sQ->front_point =0;
	sQ->rear_point =0;
	return OK;
}

//将队列清空
Status ClearQueue(SqQueue *Q){
	Q->front_point = Q->rear_point =0;
	return OK;
}

//判断队列是否为null
Status QueueEmpty(SqQueue Q){
	if(Q.front_point == Q.rear_point)
		return TRUE;
	else
		return FALSE;
}

//返回队列中的元素个数
int QueueLength(SqQueue Q){
	return (Q.rear_point-Q.front_point+MAXSIZE)%MAXSIZE;
}

//返回队头元素
Status GetHead(SqQueue Q, QElemType *e){
	if(Q.front_point == Q.rear_point)//是否为空队列
		return ERROR;
	*e = Q.data[Q.front_point];
	return OK;
}

//在队尾插入元素
Status EnQueue(SqQueue *Q, QElemType e){
	if((Q->rear_point+1)%MAXSIZE == Q->front_point)//队列已满
		return ERROR;

	Q->data[Q->rear_point] =e;//插入队尾
	Q->rear_point = (Q->rear_point +1)%MAXSIZE;//尾部指针后移，如果到最后则转到头部
	return OK;
}

//元素出队
Status DeQueue(SqQueue *Q, QElemType *e){
	if(Q->front_point == Q->rear_point)//队列空
		return ERROR;
	*e = Q->data[Q->front_point];//返回队头元素
	Q->front_point = (Q->front_point+1)%MAXSIZE;//队头指针后移，如到最后转到头部
	return OK;
}

Status visit(QElemType item){
	printf("%c\t",item);
	return OK;
}

//遍历队列元素
Status QueueTraverse(SqQueue Q){
	int i = Q.front_point;
	while((i+Q.front_point) != Q.rear_point){
		visit(Q.data[i]);
		i=(i+1)%MAXSIZE;
	}
	printf("\n");
	return OK;
}

//避免头文件被多次包含
#pragma once
#include "zhan.h"
#include "diulie.h"

typedef char* BeelzebuLang;
char** input_rule();//大写与小写字母之间的规则录入
char** input_rule2();//小写与人类语言的规则录入
SqStack delkuohao(SqQueue Q1);//处理括号内的字符串
Status is_big(char tempch,char** rule);//判断该大写字母是否有对应的规则
Status is_little(char tempch,char** rule);//判断该小写字母是否有对应的规则
SqQueue trans_to_little(SqStack S_ori,char** rule);//按照规则将大写字母换成对应的小写字母
void trans_to_human(SqQueue Qfinally,char** rule2);//将小写字母换成人类语言

#include "Mowang.h"
//大写与小写字母之间的规则录入
char** input_rule()
{
    int i = 0;
    char ch;
    char **rule;
    rule = (char**)malloc(sizeof(char**)*100);
    *rule = (char*)malloc(sizeof(char*)*100);

    //存放指针的数组，注意：声明完后，数组里的指针都是野指针，一会使用时需要malloc
    //char* rule[26];//下标0代表字母A，rule[0]存放的内容是A对应的小写字母

    for(i=0;i<26;i++)
    {
        rule[i] = "000";
    }

    while(TRUE)
    {
        printf("请输入大写字母(输入#退出程序)：");
        fflush(stdin);
        scanf("%c",&ch);
        getchar();
        if(ch == '#')
        {
            printf("规则已经完成录入！\n");
            break;
        }

        printf("请输入%c对应的小写字母串：",ch);
        rule[ch-65] = (char *)malloc(sizeof(char*)*100);//为指针申请空间
        fflush(stdin);
        gets(rule[ch-65]);
        printf("%c  -->  %s\n",ch,rule[ch-65]);
    }
    return rule;
}

//小写与人类语言的规则录入
char** input_rule2()
{
    char ch;
    int i = 0;
    //char str[1] = {'0'};
    char **rule2;
    rule2 = (char**)malloc(sizeof(char**)*100);
    *rule2 = (char*)malloc(sizeof(char*)*100);
    for(i=0;i<26;i++)
    {
        rule2[i] = "000";
    }
    while(TRUE)
    {
        printf("请输入小写字母(输入#退出程序)：");
        fflush(stdin);
        scanf("%c",&ch);
        if(ch == '#')
        {
            printf("规则已经完成录入！\n");
            break;
        }
        printf("请输入%c对应的人类语言字母串：",ch);
        rule2[ch-97] = (char *)malloc(sizeof(char*)*100);//为指针申请空间
        fflush(stdin);
        gets(rule2[ch-97]);
        printf("%c -->  %s\n",ch,rule2[ch-97]);
    }
    return rule2;
}
/*
    处理括号内的字符串
    是‘（’后的第一个字符，用firstQElemType记录下来；
    不是‘（’后的第一个字符，入栈S1；
    遇到‘）’则退出循环，开始处理括号中的数据

*/
SqStack delkuohao(SqQueue Q1)
{
    char firstQElemType = '\0',tempch = '\0';
    SqStack S1,S2;
    InitStack(&S1);
    InitStack(&S2);
    SElemType firstSElemType,e;
    DeQueue(&Q1,&firstQElemType);//括号后第一个元素出队，将其暂存到firstQElemType内
    /*
        由于Status Push(SqStack *S,SElemType e)函数的参数是SElemType，
        和firstQElemType不同，故需要特殊处理一下
    */
    firstSElemType.zi = firstQElemType;

    while(!QueueEmpty(Q1))
    {
        DeQueue(&Q1,&tempch);

        e.zi = tempch;
        if(!Push(&S1,e))//若push不成功则退出程序
        {
            printf("Push(S1)错误!!!\n");
            exit(ERROR);
        }
    }

    while(!SqStackEmpty(S1))
    {
        Push(&S2,firstSElemType);//压入左括号后第一个字符
        Pop(&S1,&e);
        Push(&S2,e);//压入右括号左边的字符
    }
    return S2;
}
//判断该大写字母是否有对应的规则
Status is_big(char tempch,char** rule)
{
    if(rule[tempch - 65] != "000")//若弹出来的字符有对应的规则，返回1
      return TRUE;
    return FALSE;
}

//判断该小写字母是否有对应的规则
Status is_little(char tempch,char** rule2)
{
    if(rule2[tempch - 97] != "000")//若弹出来的字符有对应的规则，返回1
        return TRUE;
    return FALSE;
}
//按照规则将大写字母换成对应的小写字母
SqQueue trans_to_little(SqStack S_ori,char** rule)
{
    SqQueue Qfinally;
    InitQueue(&Qfinally);
    SElemType tempe,e;
    while(!SqStackEmpty(S_ori))
    {
        Pop(&S_ori,&tempe);
        if(tempe.zi>='A'&&tempe.zi<='Z')//如果是大写字母
        {
            if(!is_big(tempe.zi,rule))//若没对应的规则
            {
                printf("\n规则缺失！");
                exit(ERROR);
            }
            char *str = rule[tempe.zi-65];//弹出的字符对应转换的规则
            int i,len = strlen(str);
            for(i=len-1; i>=0; i--)
            {
                e.zi = str[i];
                Push(&S_ori,e);//将翻译后的字符串压回S_ori
            }
        }
        else //入最终结果的队列
        {
            EnQueue(&Qfinally,tempe.zi);
        }
    }
    return Qfinally;
}
//将小写字母换成人类语言
void trans_to_human(SqQueue Qfinally,char** rule2)
{
    QElemType word;
    QueueTraverse(Qfinally);
    while(!QueueEmpty(Qfinally))
    {
        DeQueue(&Qfinally,&word);
        if(!is_little(word,rule2))//若没对应的规则
        {
            printf("\n规则缺失！");
            exit(ERROR);
        }
        printf("%s\t",rule2[word-97]);//将小写字母对应的中文打印出来
    }

}

#include "diulie.h"
#include "zhan.h"
#include "Mowang.h"
Status is_right(char* str);//判断输入的字符串是否合法

int main()
{

    SqQueue Q1,Qfina;
    InitQueue(&Q1);
    InitQueue(&Qfina);
    SqStack S_ori,S_delkuohao;
    InitStack(&S_ori);
    InitStack(&S_delkuohao);
    SElemType tempe,e;
    char *str;
    str = (char*)malloc(sizeof(char *)*100);
    printf("请输入需要翻译的魔王语言：\n");
    gets(str);
    //str = "B(ehnxgz)B";
    printf("您输入的魔王语言为:  %s\n",str);
    int i,len = strlen(str);
    if(!is_right(str))
    {
        printf("字符串不合法！");
        exit(ERROR);
    }
    for(i=len-1; i>=0; i--)
    {
        tempe.zi = str[i];//从右往左入栈
        if(tempe.zi != '(')
        {
            Push(&S_ori,tempe);//没遇到左括号就一直压栈
        }
        else//遇到左括号就开始弹栈，并把弹出来的元素入队Q1，直到遇到右括号
        {
            while(TRUE)
            {
                Pop(&S_ori,&e);//开始弹栈
                if(e.zi == ')')//遇到右括号就不弹了
                    break;
                EnQueue(&Q1,e.zi);//把弹出来的元素入队Q

            }
            S_delkuohao = delkuohao(Q1);//队Q1中的是括号内的字符串
            ClearQueue(&Q1);
            while(!SqStackEmpty(S_delkuohao))//将去括号后的字符串重新压入S_ori
            {
                Pop(&S_delkuohao,&e);
                Push(&S_ori,e);
            }

        }
    }
    printf("====去括号====\n");
    showStack(S_ori);

    char** rule,**rule2;
    rule = input_rule();
    rule2 = input_rule2();
    Qfina = trans_to_little(S_ori,rule);
    trans_to_human(Qfina,rule2);

    DestroyStack(&S_ori);
    DestroyStack(&S_delkuohao);//释放内存

	return 0;
}

Status is_right(char* str)
{
    int i,len = strlen(str);
    int lflag  = 0, rflag = 0;//左右括号的个数
    for(i = 0; i<len; i++)
    {
        if(*(str+i) == '(')
            lflag++;
        else if(*(str+i) == ')')
             rflag++;
    }
    return lflag == rflag;
}

6、结果测试
一）、友好交互信息测试
1、有输入提醒，以及输入的规则展示

2、结果展示

3、输入完成提示

4、规则缺失提醒

5、字符串括号不匹配提示

二）、去括号结果验证
1、只有大写字母没有括号

结果正确
2、括号嵌套，里面都是小写字母

3、单独一个括号，里面都是小写

4、括号里都是大写，且外面有大写和小写

5、括号嵌套，且括号里大小写都有

三）、大写换成小写以及小写换成中文结果验证