栈与队列--有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号

示例：

这里采用栈的方式，将字符串元素依次传入栈中，并在站内将元素进行匹配

代码首先需要栈对队列的接口函数，从而方便函数的实现

当获取字符串中的元素为左括号时，将其存入栈中，方便与后续入栈元素对比

传入元素为右括号时，如果栈顶元素与其不匹配，则整个字符串为false

这个思考的过程其实就是栈的实现过程。因此我们考虑使用栈，当遇到匹配的最小括号对时，我们将这对括号从栈中删除（即出栈），如果最后栈为空，那么它是有效的括号，反之不是。

代码实现：

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

typedef char STDataType;

typedef struct Stack
{
	STDataType* a;//建立一个动态数组
	int top;//栈顶
	int capacity;//栈的容量
}ST;

//接口函数
void StackInit(ST* ps);//初始化
void StackDestory(ST* ps);//销毁
void StackPush(ST* ps, STDataType x);//入栈，不分头插尾插，因为栈只能在栈顶操作
void StackPop(ST* ps);//出栈
STDataType StackTop(ST* ps);//取栈顶数据
int StackSize(ST* ps);//得到栈的数据个数
bool StackEmpty(ST* ps);//判断栈是否为空


void StackInit(ST* ps)
{
	assert(ps);
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;
	//初始top=0，意味着top指向栈顶元素的下一个
	//初始top=-1，意味着top指向栈顶元素
}

void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);//终止程序
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}
	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);//空栈时调用top直接终止程序报错
	ps->top--;//直接将栈顶数据删除，下一次有数据入栈会覆盖top位置
}

STDataType StackTop(ST* ps)//取栈顶元素
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}

int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;//如果top为零，说明栈中没有元素，为空
	//返回布尔值为1
}



bool isValid(char* s) 
{
	ST st;
	StackInit(&st);
	while (*s!='\0')//当*s==‘\0’时，字符串到达结尾处
	{
		switch (*s)
		{
			//当输入({[时，从栈顶插入数据
		case'(':
		case'{':
		case'[':
		{			
			StackPush(&st, *s);
			++s;
			break;

		}

		case')':
		case'}':
		case']':
		{
			if (StackEmpty(&st))//栈为空则销毁内存
			{
				StackDestory(&st);
				return false;
			}
			char top = StackTop(&st);//获取栈顶元素的前提是栈不为空
			StackPop(&st);
			

			if ((*s == '}' && top != '{')
				|| (*s == ')' && top != '(')
				|| (*s == ']' && top != '['))
			{
				StackDestory(&st);
				return false;
			}
			else
			{
				++s;//匹配则移向字符串的下一个字符
			}
			break;
		}
		default:
		{
			break;
		}
		}
	}
	bool ret = StackEmpty(&st);//如果每一个都匹配，则最后栈空
	StackDestory(&st);
	return ret;
}