数据结构例题（C语言）——括号匹配修改

表达式合法判断并将不合法的括号修改合法（括号包括()小括号[]中括号{}大括号）。

#include<stdio.h>
#include<stdlib.h>

#define OK 1
#define ERROR 0
#define MAX_SIZE 10
#define INIT_SIZE 10

typedef char ElemType;
typedef int status;

 typedef struct Lnode
 {
     ElemType *top;//栈顶指针 
    ElemType *base;//栈底指针
    int max;//最大存储量
 }Lnode;//节点类型
 
 //1.栈的初始化 
status Init_Stack(Lnode *p)
 {
     p->base=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType));//初始化数组 
     if(!p->base)
     {
         printf("栈初始化失败\n");
         exit(0);//初始化失败退出 
     }
     p->max=INIT_SIZE;//一些初始数据的赋值 
     p->top=p->base;//头尾指针统一 
     return OK;
 }

//2.入栈
status Push_Stack(Lnode *p,ElemType e)
{
    if(p->top-p->base>=p->max)//判断是否需要 
    {
        p->base=(ElemType*)realloc(p->base,(MAX_SIZE+p->max)*sizeof(ElemType));//需要扩容 
        if(!p->base)//扩容失败退出 
        return ERROR;
        p->top=p->base+p->max;//头指针调位置（防止产生存储空间不足，在其他存储空间开辟新的） 
        p->max=MAX_SIZE+p->max;//max修改 
    }
    *p->top=e;
    p->top++;
    return OK; 
}
 //3.出栈 
ElemType Pop_Stack(Lnode *p)
 {
     ElemType e;
     if(p->top==p->base)
         return '!';//栈为空 
     p->top--;//头指针向后移 
     e=*p->top;
     return e;
 } 
 
//4.判断 
ElemType Judg_Stack(Lnode *p,ElemType e)
{
    ElemType E=Pop_Stack(p);
    if(E=='!')//栈中无数据 
    return '!';
    switch (E)//返回相对应的符号 
         {
             case '(':
                 {
                     if(e==')')
                         return e;
                     else
                         return ')';
                     break;
                 }
             case '[':
                 {
                     if(e==']')
                         return e;
                     else
                         return ']';
                     break;
                 }
             case '{':
                 {
                     if(e=='}')
                         return e;
                     else
                         return '}';
                     break;
                 }
             default:
                 break;
           }
}


 int main()
 {
     Lnode p;
     int i=0,j=0;//用于调整数组 ，i是输入后的信息，j是调整后的信息 
    int a=0,b=0;//用于记录两种括号的数量，便于判断 
     ElemType e;
     ElemType E[100];//用于临时存储 
    
     Init_Stack(&p);//栈的初始化 
     
     printf("请输入数据(输入!结束输入)\n");
     while(1)//循环输入数据 
     {
         scanf("%c",&e);
         if(e=='!')
         {
             E[i]='!';//最后一位放上！用于结束标志 
             break;
         }
         E[i]=e;
         i++;
    }
    
    //初次调整（括号数量相等时可完成调整，不等需要二次调整）  
    i=j=0;
     while(E[i]!='!')//i是输入后的信息，j是调整后的信息 
     {
         switch (E[i])//循环初次调整括号 
         {
             case '(':
             case '[':
             case '{':
                 {
                     E[j]=E[i];//重新给数组赋值 
                     j++;
                     a++;//用于记录“([{ ”三种括号的数量 
                     Push_Stack(&p,E[i]);//入栈用于初次调整
                    break;
                 }
             case ')':
             case ']':
             case '}':
                {
                    e=Judg_Stack(&p,E[i]);
                    if(e=='!')//存在“([{ ”三种括号多余“)]} ”，调整将不再填入“)]} ”三种括号 
                    break;
                    E[j]=e;//调整数据位置 
                    j++;//用于记录“)]} ”三种括号的数量 
                    b++;
                    break;
                 }
             default:
                 E[j]=E[i];//将不是括号的数据调整位置 
                 j++;//用于记录“)]} ”三种括号的数量
                 break;
         }
         i++;
     }
     E[j]='!';//将调整好数组的末尾加上结束符号 
         
    if(a<=b)//当 “([{ ”小于等于“)]} ”时，直接输出 
    {
        j=0;
         while(E[j]!='!')
         {
         printf("%c",E[j]);
         j++;
         }
    }
    else if(a>b)//当 “([{ ”大于“)]} ”时，需将栈中所剩符号出栈并配以相对应的符号 
    {
        while(a!=b)
        {
            E[j]=Judg_Stack(&p,'(');
            b++;//调整至ab大小相等 
            j++;
            E[j]='!';
        }
        j=0;
         while(E[j]!='!')
         {
         printf("%c",E[j]);
         j++;
         }
    }
}