我們通過順序表建立一個棧

• 如果我們需要實現一組括號的匹配，我們首先必須知道這個括號陣列當中所有的括號符號。
• 常見的括號符號也就 ‘[]’ ‘{}’ ‘()’,還有的一些奇奇怪怪的括號就不說了啊。
• 我們首先需要按思維邏輯思考，需要完成括號的左右搭配，即相同型別的括號有左也有右。那麼我們必須把這個括號陣列重現的遍歷一遍，把左右區分開。
• 我們區分開了一個左括號，和有括號，那麼如果我們藉助棧，我們可以把一邊的括號全部壓入我們的佇列·當中·。
• 最後是逐個出棧，與重新分配的有括號比較。
• 可以用上switch語句，當然不用也是·可以的，畢竟這個語句我們用的都不多。

先把我們的棧作為標頭檔案定義好

#pragma once

#include <assert.h>

typedef char StackDataType;

#define	MAX_SIZE	(100)

typedef struct Stack {
	StackDataType	array[MAX_SIZE];
	int				top;	
}	Stack;

void StackInit(Stack *pStack)
{
	pStack->top = 0;
}

void StackDestroy(Stack *pStack)
{
	pStack->top = 0;
}

void StackPush(Stack *pStack, StackDataType data)
{
	assert(pStack->top < MAX_SIZE);

	pStack->array[pStack->top++] = data;
}

void StackPop(Stack *pStack)
{
	assert(pStack->top > 0);

	pStack->top--;
}

StackDataType StackTop(const Stack *pStack)
{
	assert(pStack->top > 0);

	return pStack->array[pStack->top - 1];
}

int StackSize(const Stack *pStack)
{
	return pStack->top;
}

int StackFull(const Stack *pStack)
{
	return pStack->top >= MAX_SIZE;
}

int StackEmpty(const Stack *pStack)
{
	return pStack->top <= 0;
}
 

然後定義我們的括號陣列

#include "Stack.h"
#include <string.h>
#include <stdio.h>


void BracketMatch(const char * sequence, int size)
{
	Stack	stack;
	StackInit(&stack);
	char	ch;
	char	leftBracket;

	for (int i = 0; i < size; i++) {
		ch = sequence[i];
		
		switch (ch) {
			case '(':
			case '[':
			case '{':
				StackPush(&stack, (StackDataType)ch);
				break;
			case ')':
			case ']':
			case '}':
				if (StackEmpty(&stack)) {
					printf("右括號多\n");
					StackDestroy(&stack);
					return;
				}

				leftBracket = (char)StackTop(&stack);
				StackPop(&stack);

				if (leftBracket == '(' && ch != ')') {
					printf("不匹配\n");
					return;
				}

				if (leftBracket == '[' && ch != ']') {
					printf("不匹配\n");
					return;
				}

				if (leftBracket == '{' && ch != '}') {
					printf("不匹配\n");
					return;
				}
			default:
				break;
		}
	}

	if (!StackEmpty(&stack)) {
		printf("左括號多\n");
		return;
	}

	printf("正常匹配\n");
}

void TestBracket()
{
	const char * seqs[] = {
		"(())abc{[(])}",
		"(()))abc{[]}",
		"(()()abc{[]}",
		"(())abc{[]()}"
	};

	for (int i = 0; i < 4; i++) {
		BracketMatch(seqs[i], strlen(seqs[i]));
	}
}
int main()
{
	TestBracket();
	return 0;
}