栈的应用——括号匹配

首先我们要明白栈是如何实现这个算法的，在实现算法的过程当中，栈的作用就是储存左括号，例如储存"[" "}"  '(" 这三种左括号

在程序当中，首先遍历传入的算数组，剔除一些其他的数字，在这里只比较左右括号，然后先将左括号储存到栈当中，例如（（（（ ] ] ]，先将前面的三个（压入栈当中，将左括号压入栈当中之后，就开始遍历右括号了

在遍历到右括号的时候，因为如果左右括号是匹配的，那么肯定当遍历到一个右括号的时候，就会有一个左括号在栈顶等着（因为数学当中的括号是相互匹配的，一个最左边的右括号肯定和一个最右边的右括号相互匹配，而这个最右边的左括号又在栈的顶部），如果相互匹配，那么这个时候就是匹配成功的。

根据上面是思想，如果在遍历了传入的算术组之后，栈的元素全部取出来了，那么说明全部的右括号和左括号都是匹配的

然后我们需要注意，当我们将左括号全部压入栈中的时候，可以一开始就判断栈是否是空的，如果是空的，那么就是左括号少于右括号

如果在遍历了全部的算数组之后，栈当中还有左括号，那么就是左括号多于右括号
如果在遍历右括号的时候，发现抽出来的右括号和栈顶的左括号不匹配，那么就是左右括号匹配次序不正确
 

代码

#include <stdio.h>
#include <malloc.h>
 
#define STACK_MAX_SIZE 10
 
//整数的线性堆栈
typedef struct CharStack
{
    int top;
 
    int data[STACK_MAX_SIZE];
} *CharStackPtr;
 
//输出
void outputStack(CharStackPtr paraStack)
{
    for (int i = 0; i <= paraStack->top; i ++)
	{
        printf("%c ", paraStack->data[i]);
    }
    printf("\r\n");
}
 
//初始化
CharStackPtr charStackInit()
{
	CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(struct CharStack));
	resultPtr->top = -1;
 
	return resultPtr;
}
 
//入栈 ———— paraValue要添加的值
void push(CharStackPtr paraStackPtr, int paraValue)
{
    //空间检查 判断栈是否已满
    if (paraStackPtr->top >= STACK_MAX_SIZE - 1)
	{
        printf("Cannot push element: stack full.\r\n");
        return;
    }
 
    // Step 2. Update the top.
	paraStackPtr->top ++;
 
	// Step 3. Push element.
    paraStackPtr->data[paraStackPtr->top] = paraValue;
}
 
//出栈
char pop(CharStackPtr paraStackPtr)
{
    // 空间检查 判断栈是否已空
    if (paraStackPtr->top < 0)
	{
        printf("Cannot pop element: stack empty.\r\n");
        return '\0';
    }
 
    // Step 2. Update the top.
	paraStackPtr->top --;
 
	// Step 3. Push element.
    return paraStackPtr->data[paraStackPtr->top + 1];
}// Of pop
 
//出入栈测试
void pushPopTest()
{
    printf("---- pushPopTest begins. ----\r\n");
    char ch;
    
    CharStackPtr tempStack = charStackInit();
    printf("After initialization, the stack is: ");
	outputStack(tempStack);
 
	for (ch = 'a'; ch < 'm'; ch ++)
	{
		printf("Pushing %c.\r\n", ch);
		push(tempStack, ch);
		outputStack(tempStack);
	}
 
	for (int i = 0; i < 3; i ++)
	{
		ch = pop(tempStack);
		printf("Pop %c.\r\n", ch);
		outputStack(tempStack);
	}
 
    printf("---- pushPopTest ends. ----\r\n");
}
 
//测试——括号匹配
bool bracketMatching(const char* paraString, int paraLength)
{
	// 通过在底部压入一个‘#’来初始化栈
    CharStackPtr tempStack = charStackInit();
	push(tempStack, '#');
	char tempChar, tempPopedChar;
 
	// 处理字符串
	for (int i = 0; i < paraLength; i++)
	{
		tempChar = paraString[i];
 
		switch (tempChar)
		{
		case '(':
		case '[':
		case '{':
			push(tempStack, tempChar);
			break;
		case ')':
			tempPopedChar = pop(tempStack);
			if (tempPopedChar != '(')
			{
				return false;
			}
			break;
		case ']':
			tempPopedChar = pop(tempStack);
			if (tempPopedChar != '[')
			{
				return false;
			} 
			break;
		case '}':
			tempPopedChar = pop(tempStack);
			if (tempPopedChar != '{')
			{
				return false;
			} 
			break;
		default:
			break;
		}
	}
 
	tempPopedChar = pop(tempStack);
	if (tempPopedChar != '#')
	{
		return true;
	}
 
	return true;
}
 
//函数测试
void bracketMatchingTest()
{
	const 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);
}
 
//入口
void main()
{
	//pushPopTest();
	bracketMatchingTest();
}

结果