前言

一、栈

在这里插入图片描述

C语言简单实现栈

为什么不适用链表，每次找到尾结点都需要遍历链表，时间浪费。

在这里插入图片描述

首先了解大致框架以及结构原理

Stack.h

#pragma once//防止头文件重复

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

typedef int 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);//出栈
bool StackEmpty(ST* ps);//判断栈是否为空
int StackSize(ST* ps);//栈内元素数量
STDataType StackTop(ST* ps);//栈顶元素

void StackInit(ST* ps);//栈初始化

void StackDestory(ST* ps);//栈的销毁

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

void StackPop(ST* ps);//出栈

bool StackEmpty(ST* ps);//判断栈是否为空

int StackSize(ST* ps);//栈内元素数量

STDataType StackTop(ST* ps);//栈顶元素

二、队列

C语言简单实现队列

大致框架与结构原理

到头来，不就是单链表头尾操作吗。请添加图片描述

Queue.h

#pragma once
// 链式结构：表示队列 
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* front;
	QNode* rear;
}Queue;

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);

初始化队列

队尾入队列

队头出队列

获取队列头部元素

获取队列队尾元素

获取队列中有效元素个数

检测队列是否为空，如果为空返回非零结果，如果非空返回0

销毁队列

括号匹配问题

括号匹配题目链接

思路

考虑到需要使用栈，我们可以之间把我们实现的栈拿来用（这里是C语言频道，STL暂不涉及）
剩下的就是把思想用代码实现

//这样部分可以拿来放到开头
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;			//栈顶的位置
	int capacity;       //容量
}ST;

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
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)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;	
		ps->a = (STDataType*)realloc(ps->a, newCapacity * sizeof(STDataType));
		if (ps->a == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->capacity = newCapacity;
	}

	ps->a[ps->top] = x;
	ps->top++;
}
void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;

}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}

bool isValid(char * s){
    ST st;//创建一个栈
    StackInit(&st);

    while(*s)//题目传了一个括号数组进来
    {
        if(*s == '(' || *s == '{' || *s == '[')//左括号入栈
        {
            //入栈
            StackPush(&st, *s);
            s++;
        }
        
        else
        {
            //匹配
            if(StackEmpty(&st))//直到遇到第一个右括号也没有左括号，括号不匹配
            {
                return false;
            }
            //栈内有左括号，可以进行匹配
            char top = StackTop(&st);//拿到了栈顶的数据并记录，因为下一步会删除
            StackPop(&st);//匹配后需要与它左边的括号继续匹配直到匹配完

            if(*s == ']' && top != '[' 
            || *s == '}' && top != '{'
            || *s == ')' && top != '(')//不匹配
            {
                StackDestory(&st);防止内存泄漏，因为栈是我们自行开辟的
                return false;
            }
            else//单个括号匹配
            {
                //继续比
                ++s;//找到s里的下一个括号，再次判断需要入栈还是与前面剩余也是栈顶的括号进行匹配
            }
        }
    }

    bool ret = StackEmpty(&st);//栈为空，就说明全部匹配

    StackDestory(&st);//栈是自己开辟的
    return ret;
}