LeetCode20 Paréntesis válidos - C pura

"Mirando y luciendo desamparado y solo, desolado y miserable"
"Tres copas y dos copas de vino ligero, ¿cómo puede tener prisa por la noche?"

Este problema es un problema de coincidencia de corchetes, que es una aplicación típica de las pilas.

La forma de crear uno 顺序栈se ha implementado en la publicación de blog anterior: Portal .

Tema Descripción

Dada una cadena s que contiene solo '(', ')', '{', '}', '[', ']', determine si la cadena es válida.

Una cadena válida debe satisfacer:

1. Los paréntesis de apertura deben cerrarse con paréntesis de cierre del mismo tipo.
2. Los paréntesis izquierdos deben cerrarse en el orden correcto.

enlace de tema

LeetCode20 Paréntesis válidos Simple

análisis de tema

El problema de coincidencia de corchetes, una aplicación típica a la pila de estructuras de datos.
En mi nivel actual de estructura de datos de principiante, aunque LeetCode muestra que es un problema simple, no es fácil para mí, y la reserva de conocimiento no es suficiente, es muy engorroso resolverlo con C puro.
Mi idea es crear primero una pila con una estructura secuencial y luego usar las funciones básicas de la pila como: empujar la pila (StackPush), abrir la pila (StackPop), colocar los elementos en la parte superior de la pila (StackTop ) y otras funciones para completar este problema.

Ideas:
1. Recorra toda la cadena "'(',')','{','}','[',']'".
2. En el proceso de desplazamiento, si encuentra un corchete de apertura '(', o '{', o '[', realice una operación de inserción de pila (StackPush).
3. Si encuentra un corchete de cierre ')', o '}', o ']', se realiza la operación de acceder al valor del elemento superior de la pila (StackTop), y si el paréntesis izquierdo en la parte superior de la pila coincide con uno de los paréntesis de cierre, la operación de extracción de la pila (StackPop) se realiza.
4. Hasta que la cuerda esté fuera de los límites, el ciclo termina.

Código

Nota: En el proceso de implementación, debe prestar atención a los casos extremos.
Las situaciones normales pueden ser imaginadas por personas normales. Y los casos extremos no lo son necesariamente.
Y no se da el ejemplo del título.
1. ¿Qué sucede si solo queda un paréntesis ‘（’?
//Sugerencia: cuando solo queda un paréntesis, la pila no está vacía.
2. ¿Qué sucede si solo hay un paréntesis de cierre ‘）’?
//Sugerencia: la pila está vacía cuando solo hay un paréntesis de cierre.

/***********
*结构体创建
***********/
typedef char STDataType;

typedef struct Stack
{
    
    
	STDataType* a;
	int top;
	int capacity;
}ST;
/***********
*函数的声明
***********/

//初始化结构体
void StackInit(ST* ps);
//销毁结构体
void StackDestroy(ST* ps);
//压栈
void StackPush(ST* ps, STDataType x);
//出栈
void StackPop(ST* ps);
//得到栈顶的值
STDataType StackTop(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);
//得到栈的长度
int StackSize(ST* ps);

/***********
*函数的定义
***********/

//初始化结构体
void StackInit(ST* ps)
{
    
    
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
//销毁结构体
void StackDestroy(ST* ps)
{
    
    
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;


}
//压栈
void StackPush(ST* ps, STDataType x)
{
    
    

	assert(ps);
	if (ps->top == ps->capacity)
	{
    
    
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* new = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
		if (new == NULL)
		{
    
    
			printf("realloc fail\n");
			exit(-1);
		}
		ps->a = new;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
//出栈
void StackPop(ST* ps)
{
    
    
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}
//访问栈顶元素
STDataType StackTop(ST* ps)
{
    
    
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}
//判断栈是否为空
bool StackEmpty(ST* ps)
{
    
    
	assert(ps);
	return ps->top == 0;
}
//得到栈的长度
int StackSize(ST* ps)
{
    
    
	assert(ps);
	return ps->top;
}

/***********
*题目函数接口
***********/
bool isValid(char* s)
{
    
    
	ST st;
	//创建栈，否则后续压栈等操作无法实现
	StackInit(&st);
	while (*s)
	{
    
    

		if (*s == '(' || *s == '{' || *s == '[')
		{
    
    
			StackPush(&st, *s);
			s++;
		}
		else
		{
    
    
		//只有一个右括号时，栈为空。直接return false
			if (StackEmpty(&st))
			{
    
    
				return false;
			}
			char top = StackTop(&st);
			if (*s == ')' && top == '(' || *s == '}' && top == '{' || *s == ']' && top == '[')
			{
    
    
				StackPop(&st);
				s++;
			}
			else
			{
    
    
				return false;
			}
		}
	}
	//处理只有一个左括号
	
	if (!StackEmpty(&st))
	{
    
    
		return false;
	}
	return true;
	//销毁栈，拒绝内存泄漏
	StackDestroy(&st);
}