设计一个算法判定一个算术表达式中的括号是否正确配对（包括三种括号并且需要考虑大中小三种括号的嵌套顺序）, 并将对应的程序调试运行通过。

算法思想：

暂不考虑数据元素的运算，只考虑括号的配对。则有两个概念：对右括号期待的急迫程度和当前括号的优先级。因此前者的特点符合栈的特点，即后遍历到的括号，急迫程度越强。因此使用一个栈来存储遍历到的括号，遇到左括号则入栈，遇到右括号，如果匹配当前左括号则出栈，如果不匹配则跳出报错，如果出现了有右括号无左括号或遍历完成不是空栈的情况，则跳出报错。
第二个概念则使用一个变量来表示优先级，每做一次入栈或出栈的操作，则检查一下当前栈顶元素的优先级来确定当前括号的优先级，如果入栈的左括号优先级低于当前等级，则跳出报错。

C语言代码实现：

//使用栈实现括号的匹配 
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

//定义一个栈
typedef struct Stack{
    char *top;
    char *bottom;
    int size;
}Stack,*PStack;

void initStack(PStack x,int s){
    x->size=s;
    x->bottom=(char*)malloc(sizeof(char)*(s+1));
    if(!x->bottom)
        exit(0);
    x->top=x->bottom;
}

int judgeEmpty(PStack x){
    if(x->bottom==x->top)
        return 1;
    return 0;
}

int judgeFilled(PStack x){
    if(x->bottom-x->top==x->size)
        return 1;
    return 0;
}

int push(PStack x,char in){
    if(judgeFilled(x)==1)
        return 1;
    *(x->top)=in;
    x->top++;
    return 0;
}

int pop(PStack x){
    if(judgeEmpty(x)==1)
        return 1;
    --(x->top);
    return 0;
} 

int bracketMatch(char *x){
    PStack stack=(PStack)malloc(sizeof(Stack));
    initStack(stack,50);
    int i=0,level=-1;

    while(x[i]!='\0'&&judgeFilled(stack)==0){
        switch(x[i])
        {
            case '(':
                push(stack,'(');
                level=2;
                break;
            case '[':
                if(level>1)
                    return 0;
                level=1;
                push(stack,'[');
                break;
            case '{':
                if(level>0)
                    return 0;
                level=0;
                push(stack,'{');
                break;
            case ')':
                if(judgeEmpty(stack)==1||*(stack->top-1)!='(')
                    return 0;
                pop(stack);
                switch(*stack->top-1)
                {
                    case '(':
                        level=2;
                        break;
                    case '[':
                        level=1;
                        break;
                    case '{':
                        level=0;
                        break;
                }
                break;
            case ']':
                if(judgeEmpty(stack)==1||*(stack->top-1)!='[')
                    return 0;
                pop(stack);
                switch(*stack->top-1)
                {
                    case '(':
                        level=2;
                        break;
                    case '[':
                        level=1;
                        break;
                    case '{':
                        level=0;
                        break;
                }
                break;
            case '}':
                if(judgeEmpty(stack)==1||*(stack->top-1)!='{')
                    return 0;
                pop(stack);
                switch(*stack->top-1)
                {
                    case '(':
                        level=2;
                        break;
                    case '[':
                        level=1;
                        break;
                    case '{':
                        level=0;
                        break;
                }
                break;
            default:
                printf("o\n");
                break;
        }
        i++;
    }
    if(judgeEmpty(stack)==0)
        return 0;

    free(stack);
    return 1;
}

int main(){
    printf("请输入表达式：");
    char c[50];
    scanf("%s",c);

    if(bracketMatch(c)==1)
        printf("YES!\n");
    else
        printf("NO!\n");

    return 0;
}