括号匹配------栈的应用

1.先上代码，再讲废话

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<malloc.h>

#define STACK_MAX_SIZE 10

/*
* Linear stack of integers. The key is data.
* 整数的线性堆栈。关键是数据.
*/
typedef struct CharStack {
	int top;

	int data[STACK_MAX_SIZE]; //The maximum length is fixed.
} *CharStackPtr;

/*
* Output the stack.
*/
void outputStack(CharStackPtr paraStack) {
    for (int i = 0; i <= paraStack->top; i++) {
        printf("%c ", paraStack->data[i]);
    }// Of for i
    printf("\r\n");
}// Of outputStack

/*
*Initialize an empty char stack. No error checking for this function.
* paraStack The pointer to the stack. It must be a pointer to change the stack.
* paraValues An int array storing all elements.
*/
CharStackPtr charStackInit() {
    CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(struct CharStack));
    resultPtr->top = -1;

    return resultPtr;
}//Of charStackInit

/*
*Push an element to the stack.
* paraValue The value to be pushed.
*/
void push(CharStackPtr paraStackPtr, int paraValue) {
    // Step 1. Space check.
    if (paraStackPtr->top >= STACK_MAX_SIZE - 1) {
        printf("Cannot push element: stack full.\r\n");
        return;
    }// of if

    //Step 2. Update the top.
    paraStackPtr->top++;

    //Step 3. Push element.
    paraStackPtr->data[paraStackPtr->top] = paraValue;
}// of push

/*
* Pop an element from the stack.
* returned The popped value.
*/
char pop(CharStackPtr paraStackPtr) {
    // Step 1. Space chek.
    if (paraStackPtr->top < 0) {
        printf("Cannot pop element: srack empty.\r\n");
        return '\0';
    }// of if

    // Step 2. Updata the top.
    paraStackPtr->top--;

    // Step 3. push element.
    return paraStackPtr->data[paraStackPtr->top + 1];
}// of top

/*
* Test the push function.
*/
void pushPopTest() {
    printf("----pushPopTest begins ----\r\n");
    char ch;

    // Initialize.
    CharStackPtr tempStack = charStackInit();
    printf("After initialization, the stack is: ");
    outputStack(tempStack);

    // Push.
    for (ch = 'a'; ch < 'm'; ch++) {
        printf("Pushing%c.\r\n", ch);
        push(tempStack, ch);
        outputStack(tempStack);
    }// of for i

    // Pop.
    for (int i = 0; i < 3; i++) {
        ch = pop(tempStack);
        printf("Pop %c.\r\n", ch);
        outputStack(tempStack);
    }// of pushPoptest
}

/*
* Is the bracket matching?
* 
* paraString The given expression.
* Match or not.
*/
bool bracketMatching(char* paraString, int paraLength) {
    // Step 1. Initialize the stack through pushing a '#' at the bottom.
    CharStackPtr tempStack = charStackInit();
    push(tempStack, '#');
    char tempChar, tempPopChar;

    // Step 2. Process the string.
    for (int i = 0; i < paraLength; i++) {
        tempChar = paraString[i];

        switch (tempChar) {
        case'(':
        case'[':
        case'{':
            push(tempStack, tempChar);
            break;
        case')':
            tempPopChar = pop(tempStack);
            if (tempPopChar != '(') {
                return false;
            }// of if
            break;
        case']':
            tempPopChar = pop(tempStack);
            if (tempPopChar != '[') {
                return false;
            }// of if
            break;
        case'}':
            tempPopChar = pop(tempStack);
            if (tempPopChar != '{') {
                return false;
            }// of if
            break;
        default:
            // Do nothing
            break;
        }// of switch
    }// of fot i
    tempPopChar = pop(tempStack);
    if (tempPopChar != '#') {
        return true;
    }// of if

    return true;
}// of bracketMatching

/*
* Unit test.
*/
void bracketMatchingTest() {
    char* tempExpression = "[2 + (1 - 3)] * 4";
    bool tempMatch = bracketMatching(tempExpression, 17);
    printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);


    tempExpression = "( )  )";
    tempMatch = bracketMatching(tempExpression, 6);
    printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);

    tempExpression = "()()(())";
    tempMatch = bracketMatching(tempExpression, 8);
    printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);

    tempExpression = "({}[])";
    tempMatch = bracketMatching(tempExpression, 6);
    printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);


    tempExpression = ")(";
    tempMatch = bracketMatching(tempExpression, 2);
    printf("Is the expression '%s' bracket matching? %d \r\n", tempExpression, tempMatch);
}// Of bracketMatchingTest

/*
* The entrance.
*/
void main() {
    // pushPoptest();
    bracketMatchingTest();
}// of main

很奇怪，VS在抄写代码时，遇到bracketMatchingTest的时候，

char* tempExpression = "[2 + (1 - 3)] * 4";

会出现报错，报错原因是

 const char*类型的值不能用于初始化char*类型的实体

但是我将代码复制到DEVC++上，代码能够运行

2.运行结果

 3.收获

括号匹配，在一些简单的字符串中，人能够一眼看出来，但字符串长了之后，计算机就显得更加聪明了。

括号匹配，在遇到一些前缀/后缀表达式求值，即（逆）波兰表达式时，将这些表达式转化成中缀表达式也需要利用算术优先级以及括号匹配，不过之前我都是利用一个栈来实现，或者采用更简单的Python的列表来实现，老师讲的利用两个栈来实现复杂表达式计算值得学习。