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、括号嵌套,且括号里大小写都有
三)、大写换成小写以及小写换成中文结果验证