設計一個演算法判定一個算術表示式中的括號是否正確配對（包括三種括號並且需要考慮大中小三種括號的巢狀順序）, 並將對應的程式除錯執行通過。

演算法思想：

暫不考慮資料元素的運算，只考慮括號的配對。則有兩個概念：對右括號期待的急迫程度和當前括號的優先順序。因此前者的特點符合棧的特點，即後遍歷到的括號，急迫程度越強。因此使用一個棧來儲存遍歷到的括號，遇到左括號則入棧，遇到右括號，如果匹配當前左括號則出棧，如果不匹配則跳出報錯，如果出現了有右括號無左括號或遍歷完成不是空棧的情況，則跳出報錯。
第二個概念則使用一個變數來表示優先順序，每做一次入棧或出棧的操作，則檢查一下當前棧頂元素的優先順序來確定當前括號的優先順序，如果入棧的左括號優先順序低於當前等級，則跳出報錯。
 

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;
}