#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");
}

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

不好意思啊，没有注意啊，才看到这贴。我看了下，你确定你的栈和顺序表都没有问题？，你可以分开测试下,还有就是你的比较应该是顺序表的元素和栈定元素比较吧。虽然你用了赋值的方法，但这种方法，你没注意像是顺序表的元素前后元素在比较吧，既然你用了链式栈，就用栈定元素和顺序表的比较吧。可能我错了。明天我帮你改改，真不好意思啊。

那谢谢你咯！

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


#include<iostream>    //头文件
#include<stdlib.h>
using namespace std;
#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;                //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]); //将正在检查的元素入栈
      //cout<<top->data;
        // top_elem=i;                                 //将栈顶元素的下标赋给top_elem
    }
    else   if(match(top->data,L->data[i])) //如果栈不为空，则将此时正在检查的元素与栈顶元素比较是否相配
    {
        top=poplstack(top);                             //若相配，则将栈顶元素出栈
        //top_elem-=1;
    }else
    {top=push(top,L->data[i]);
    }
   


    }
    if(Empty(top))                     //全部检查完毕后，判断此时的栈是否为空
        return OK;                    //如果为空，则返回OK
    else                                //否则，返回FALSE
        return FALSE;
    //display(top);
}
//函数实现
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;
    r=p;
    return r;
}

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


int match(char c1,char c2)               //判断是否匹配的函数，若匹配的话，则返回OK，否则就返回FALSE
{
    if(((c1=='('&&c2==')')||(c1==')'&&c2=='('))||((c1=='{'&&c2=='}')||(c1=='}'&&c2=='{'))||((c1=='['&&c2==']')||(c1==']'&&c2=='[')))
    //if(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");
    for(i=0;i<m;i++)                                    //为线性表的元素赋值
    {
        cin>>A->data[i];
    }
    A->last=m;
    x=check_pair(A);//将函数的返回值赋给x，若全部匹配成功，则x为OK,否则x为FALSE
    if(x)
    printf("全部匹配成功；\n");
    else printf("未匹配完成；\n");

}//真的很不好意思啊，改我到是帮你改了，你看下可以不，你那个c语言的输入我昨天弄了好久还是，刚输入一个字符，它就不让输了。让我很郁闷啊。你可以仿照改成c语言//的//输入，应该也没有问题，你要知道我数据就够才考40分的，不解释啦，有不明白的，我们再讨论。共同学习啊

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

我也是够忙的。不客气啊，都是学习啦