多重括号的解决办法就是：
先设置一个栈，遇到左括号时，压栈，不断地压，直到遇到右括号。一旦遇到了右括号就不断地出栈，直到出一个左括号，然后把这些字符解释，解释后压到栈里去。然后再不断地压栈，直到遇到下一个右括号，如此往复。
多条规则的解决办法就是：
最简单的方法就是 来回多扫描几遍。：）
#include<stdio.h>#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef struct//定义栈结构体
{
char *base
char *top
int stacksize
}SqStack
typedef struct QNode//定义队结构体
{
char data
struct QNode *next
}QNode,*QueuePtr
typedef struct//定义队头队尾指针 结构体
{
QueuePtr front
QueuePtr rear
}LinkQueue
int InitStack(SqStack &S)
int GetTop(SqStack S,char &e)
int Push(SqStack &S,char e)
int Pop(SqStack &S,char &e)
int InitQueue(LinkQueue &Q)
int EnQueue(LinkQueue &Q,char e)
int DeQueue(LinkQueue &Q, char &e)
int translate(char *p,int len,SqStack &S,LinkQueue &Q)
int main()
{
char str[100][100]
int i=0,d=0
int len
char *p
SqStack S
LinkQueue Q
InitStack(S)
InitQueue(Q)
scanf("%s",str[0])
while(str[i][0]!='*')
{
scanf("%s",str[++i])//将N组数据放入二维数组中
d++//d为数据组数N（不含***）
}
for(i=0i<di++)
{
p=str[i]
len=strlen(str[i])
translate(p,len,S,Q)
}
return 0
}
int translate(char *p,int len,SqStack &S,LinkQueue &Q)
{
int D=0
char e,q
p=p+len-1
while(D<len){
while(*p!='('&&D<len)//'('前的入栈
{
Push(S,*p)
--p
D++
}
if(D==len) break
while(*(S.top-1)!=')')//栈顶元素不为')'的出栈入队列
{
Pop(S,e)
EnQueue(Q,e)
}
if(*(S.top-1)==')'&&D!=len) Pop(S,e)//将')'出栈
while(Q.front!=Q.rear)//如果队列中有元素则将首元素出队列入栈
{
DeQueue(Q,q)//q为xita
Push(S,q)
break
}
while(Q.front!=Q.rear&&D!=len)//出队列入栈
{
DeQueue(Q,e)
Push(S,e)
Push(S,q)
}
if(*p=='(')
p=p-1
}
while(S.top!=S.base)
{
Pop(S,e)
if(e=='B')
printf("tsaedsae")
else if(e=='A')
printf("sae")
else if(e=='\0') continue
else
printf("%c",e)
}
printf("\n")
return 0
}
int InitStack(SqStack &S)
{
S.base=(char*)malloc(STACK_INIT_SIZE*sizeof(char))
S.top=S.base
S.stacksize=STACK_INIT_SIZE
return OK
}
int GetTop(SqStack S,char &e) //获取栈顶元素并用e返回
{
if(S.top = S.base) return ERROR
e=*(S.top-1)
return OK
}
int Push(SqStack &S,char e) //元素e入栈
{
if(S.top-S.base>=S.stacksize)
{
S.base = (char*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(char))
if(!S.base) exit(OVERFLOW)
S.top = S.base+S.stacksize
S.stacksize+=STACKINCREMENT
}
*S.top++=e
return OK
}
int Pop(SqStack &S,char &e) //出栈将栈顶元素赋值于e
{
if(S.top==S.base) return ERROR
e=*--S.top
return OK
}
int InitQueue(LinkQueue &Q) //建立一个空队
{
Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode))
if(!Q.front) exit(OVERFLOW)
Q.front->next=NULL
return OK
}
int EnQueue(LinkQueue &Q,char e) //插入元素e为新的队尾元素
{
QueuePtr p
p = (QueuePtr)malloc(sizeof(QNode))
if(!p) exit(OVERFLOW)
p->data = e
p->next = NULL
Q.rear->next = p
Q.rear = p
return OK
}
int DeQueue(LinkQueue &Q, char &e)//删除Q的队头元素并用e返回
{
QueuePtr p
if(Q.front==Q.rear)exit(OVERFLOW)
p=Q.front->next
e=p->data
Q.front->next = p->next
if(Q.rear==p)
Q.rear=Q.front
free(p)
return OK
}
简单地理解就是多重括号的解决办法就是：
先设置一个栈，遇到左括号时，压栈，不断地压，直到遇到右括号。一旦遇到了右括号就不断地出栈，直到出一个左括号，然后把这些字符解释，解释后压到栈里去。然后再不断地压栈，直到遇到下一个右括号，如此往复。
多条规则的解决办法就是：
最简单的方法就是 来回多扫描几遍。：）
