栈的应用之括号匹配

复现闵帆老师的博客，地址：数据结构 C 代码 3.2: 栈的应用 -- 括号匹配_在c语言实现栈的应用—表达式括号匹配检查-CSDN博客

代码复现

#include<stdbool.h>
#include<stdio.h>
#include<malloc.h>

#define STACK_MAX_SIZE 10   // 定义一个宏，用来限制栈的最大容量

 
// 定义一个字符栈结构体，用来表示一个线性栈
typedef struct CharStack {
	int top;

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


// 初始化一个空的字符栈
// @param paraStackPtr 栈的指针。必须使用指针才能修改栈的内容。
// @param paraValues 一个整型数组，用于存储所有元素。
CharStackPtr charStackInit() {
	CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(struct CharStack));
	resultPtr->top = -1;   // 表示新初始化的栈为空

	return resultPtr;
}


// 压栈，压入一个元素
// @param paraValue 被压入的元素
void push(CharStackPtr paraStackPtr, int paraValue) {

	// Step1.检查空间
	if (paraStackPtr->top >= STACK_MAX_SIZE - 1) {
		printf("Cannot push element: stack full.\r\n");
		return;
	}

	// Step2.更新栈顶
	paraStackPtr->top++;

	// Step3.压栈
	paraStackPtr->data[paraStackPtr->top] = paraValue;

} 


// 弹栈，弹出一个元素
// @return 弹出的元素
char pop(CharStackPtr paraStackPtr) {

	// Step1.检查空间
	if (paraStackPtr->top < 0) {
		printf("Cannot pop element: stack empty.\r\n");
		return '\0';  // 返回空字符，表示栈里什么都没有
	}

	// Step2.更新栈顶
	paraStackPtr->top--;

	// Step3.弹出元素
	return paraStackPtr->data[paraStackPtr->top + 1];   // 返回被弹出的元素（也就是原本的栈顶元素）

}


// 检查压栈与弹栈的函数
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");
}


// 检查括号是否匹配
// @param paraString 给定的表达式
// @param paraLength 表达式的长度
// @return 是否匹配（true 表示匹配，false 表示不匹配）
bool bracketMatching(const char* paraString, int paraLength) {

	// Step1.初始化栈，并压入底部符号#用于判断最后是否全部匹配
	CharStackPtr tempStack = charStackInit();
	push(tempStack, '#');
	char tempChar;          // 表示当前正在处理的字符
	char tempPopedChar;     // 表示从栈中弹出的字符

	// Step2.逐个处理表达式中的字符
	for (int i = 0; i < paraLength; i++) {   // 从第一个字符开始遍历
		tempChar = paraString[i];

		switch (tempChar) {
		// 遇到左括号就压栈
		case '(':
		case '[':
		case '{':
			push(tempStack, tempChar);
			break;

		// 遇到右括号就弹栈并且匹配
		case ')':
			tempPopedChar = pop(tempStack);  // 弹出top位置的字符
			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;
		} // switch结束
	} // for循环结束

	// 遍历结束之后检查还剩下的字符是否为#
	tempPopedChar = pop(tempStack);
	if (tempPopedChar != '#') {
		return false;
	}

	return true;
}


// 对bracketMatching函数的测试
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);

	printf("（返回'1'表示成功匹配；返回'0'表示无法成功匹配）")
} // bracketMatchingTest函数结束


// 入口
void main() {
	bracketMatchingTest();
}

运行结果

Is the expression '[2 + (1 - 3)] * 4' bracket matching? 1
Is the expression '( )  )' bracket matching? 0
Is the expression '()()(())' bracket matching? 1
Is the expression '({}[])' bracket matching? 1
Is the expression ')(' bracket matching? 0
（返回'1'表示成功匹配；返回'0'表示无法成功匹配）

只需要一个栈就能够实现括号匹配这件事