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

#define OK 1
#define FALSE 0
#define maxsize 1024
typedef struct node
{
    char data;
    struct node *next;
}linkstack;

linkstack *setnull(linkstack *r);
int Empty(linkstack *r);
linkstack *push(linkstack *r,char ch);
int match(char c1,char c2);
linkstack *poplstack(linkstack *r);

typedef struct
{
    char data[maxsize];
    int last;
}sequenlist;

int check_pair(sequenlist *L)
{
    linkstack *top;
    int i;
    top=(linkstack *)malloc(sizeof(linkstack));
    top=setnull(top);
    int top_elem;
    for(i=0;i<=(*L).last;i++)
    {
    if(Empty(top))
    {
        top=push(top,L->data[i]);
        top_elem=i;
    }
    else if(match(L->data[top_elem],L->data[i]))
    {
        top=poplstack(top);
        top_elem-=1;
    }
    else
    {
        top=push(top,L->data[i]);
        top_elem=i;
    }


    }
    if(Empty(top))
        return OK;
    else
        return FALSE;
}

linkstack *setnull(linkstack *r)
{
    r=NULL;
    return r;
}

int Empty(linkstack *r)
{
    if(r==NULL)
    return OK;
    else return FALSE;
}

linkstack *push(linkstack *r,char ch)
{
    linkstack *p;
    p=(linkstack *)malloc(sizeof(linkstack));
    p->data=ch;
    p->next=r;
    return p;
}

linkstack *poplstack(linkstack *r)
{
    linkstack *p;
    p=r->next;
    free(r);
    return p;
}


int match(char c1,char c2)
{
    if(((c1=='('&&c2==')')||(c1==')'&&c2=='('))||((c1=='{'&&c2=='}')||(c1=='}'&&c2=='{'))||((c1=='['&&c2==']')||(c1==']'&&c2=='[')))
    return OK;
    else return FALSE;
}



void main()
{
    sequenlist *A;
    A=(sequenlist *)malloc(sizeof(sequenlist));
    int m,x,i;
    printf("请输入元素个数：\n");
    scanf("%d",&m);
    printf("\n");
    printf("请输入带验证匹配的符号:\n");
    for(i=0;i<m;i++)
    {
        scanf("%c",&A->data[i]);
    }
    A->last=m-1;
    x=check_pair(A);
    if(x)
    printf("全部匹配成功；\n");
    else printf("未匹配完成；\n");
}

算法思想：将要判断是否匹配的符号，放在一个线性表里，然后准备一个空栈，逐个检查符号，
若栈为空，则将符号入栈。若栈不为空，则将此元素与栈顶元素比较。若相匹配，则将栈顶元素出栈。
否则入栈。当所有符号检查完毕，判断此时的栈是否为空，若为空则所有符号都匹配，否则没有全部匹配。


#include<stdio.h>    //头文件
#include<stdlib.h>

#define OK 1
#define FALSE 0
#define maxsize 1024
typedef struct node       //节点定义
{
    char data;         
    struct node *next;
}linkstack;

linkstack *setnull(linkstack *r);    //置空函数声明,返回值指向栈的指针类型
int Empty(linkstack *r);              //判断是否为空的函数声明，若为空则返回OK，否则返回FALSE
linkstack *push(linkstack *r,char ch);    //入栈函数 ，返回值为新的栈顶指针
int match(char c1,char c2);               //判断符号是否匹配的函数，若匹配则返回值为OK,否则返回值为FALSE
linkstack *poplstack(linkstack *r);        //元素出栈的函数 返回值为新的栈顶指针

typedef struct                       //线性表的定义
{
    char data[maxsize];
    int last;
}sequenlist;

int check_pair(sequenlist *L)              //检查是否所有符号都匹配的函数，返回值为1或0；参数为
{                                          //指向线性表的指针
    linkstack *top;                          //栈指针，指向栈顶部。
    int i;
    top=(linkstack *)malloc(sizeof(linkstack));     //将栈初始化
    top=setnull(top);                               //置空栈
    int top_elem;                                   //用top_elem来指向栈顶的元素。
    for(i=0;i<=(*L).last;i++)                      //利用for循环来逐个检查符号
    {
    if(Empty(top))                                //若栈空
    {
        top=push(top,L->data[i]);                  //将正在检查的元素入栈
        top_elem=i;                                 //将栈顶元素的下标赋给top_elem
    }
    else if(match(L->data[top_elem],L->data[i]))        //如果栈不为空，则将此时正在检查的元素与栈顶元素比较是否相配
    {
        top=poplstack(top);                             //若相配，则将栈顶元素出栈
        top_elem-=1;
    }
    else
    {
        top=push(top,L->data[i]);                      // 若不相配，则将正在检查的元素入栈
        top_elem=i;
    }


    }
    if(Empty(top))                     //全部检查完毕后，判断此时的栈是否为空
        return OK;                    //如果为空，则返回OK
    else                                //否则，返回FALSE
        return FALSE;
}
//函数实现
linkstack *setnull(linkstack *r)         //置空函数，返回值是一个指向栈的指针
{
    r=NULL;
    return r;
}

int Empty(linkstack *r)           //判断是否为空的函数，若为空则返回OK，否则就返回FALSE
{
    if(r==NULL)
    return OK;
    else return FALSE;
}

linkstack *push(linkstack *r,char ch)      //符号入栈的函数，利用前插法入栈，返回值是新的栈顶指针
{
    linkstack *p;
    p=(linkstack *)malloc(sizeof(linkstack));
    p->data=ch;
    p->next=r;
    return p;
}

linkstack *poplstack(linkstack *r)             //符号出栈的函数，返回值为新的栈顶指针
{
    linkstack *p;
    p=r->next;
    free(r);
    return p;
}


int match(char c1,char c2)               //判断是否匹配的函数，若匹配的话，则返回OK，否则就返回FALSE
{
    if(((c1=='('&&c2==')')||(c1==')'&&c2=='('))||((c1=='{'&&c2=='}')||(c1=='}'&&c2=='{'))||((c1=='['&&c2==']')||(c1==']'&&c2=='[')))
    return OK;
    else return FALSE;
}



void main()                      //主函数
{
    sequenlist *A;                                   //定义线性表指针
    A=(sequenlist *)malloc(sizeof(sequenlist));         //为指针分配内存
    int m,x,i;
    printf("请输入元素个数：\n");                      //输入符号的个数，以便用for循环为线性表赋值
    scanf("%d",&m);
    printf("\n");
    printf("请输入带验证匹配的符号:\n");
    for(i=0;i<m;i++)                                    //为线性表的元素赋值
    {
        scanf("%c",&A->data[i]);
    }
    A->last=m-1;
    x=check_pair(A);                                 //将函数的返回值赋给x，若全部匹配成功，则x为OK,否则x为FALSE
    if(x)
    printf("全部匹配成功；\n");
    else printf("未匹配完成；\n");
}

我改用链表来存放符号后，程序没有问题，但用这个程序则总是未匹配成功；
不知道为什么用线性表就错了；

那谢谢你咯！

我这些天在忙于学习，没看到，真的很感谢你！！