4.1栈和队列基本概念+经典OJ题

本篇博客来梳理栈和队列基本概念以及一道经典OJ题，题目已插入超链接，点击即可跳转~

一、栈的相关概念

1．栈

一种特殊的线性表，只允许在固定的一端插入和删除元素，栈中的数据遵循后进先出原则

（1）栈顶：进行数据插入和删除操作的一端

（2）栈底：栈顶的另一端

2．压栈：栈的插入操作

3．出栈：栈的删除操作

4．栈的实现：用数组较优，原因是数组尾插代价比较小

（1）Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

（2）Stack.c

#include"Stack.h"
void StackInit(Stack* ps)// 初始化栈 
{
	assert(ps);
	ps->_a = NULL;
	ps->_top = 0;
	ps->_capacity = 0;
}

void StackPush(Stack* ps, STDataType data)//入栈(数组的尾插)
{
	assert(ps);
	if (ps->_capacity == ps->_top)
	{
		int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->_a,newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc failed!");
			return;
		}
		ps->_a = tmp;
		ps->_capacity = newcapacity;
	}
	ps->_a[ps->_top] = data;
	ps->_top=ps->_top + 1;
}

void StackPop(Stack* ps)//出栈（去掉数组最后一个元素）
{
	assert(ps);
	assert(ps->_top > 0);
	ps->_top--;
}

STDataType StackTop(Stack* ps)//获取栈顶元素
{
	assert(ps);
	assert(ps->_top);
	return ps->_a[ps->_top-1];
}

int StackSize(Stack* ps)//获取栈中有效元素个数
{
	assert(ps);
	return ps->_top;
}

bool StackEmpty(Stack* ps)// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
{
	assert(ps);
	return ps->_top == 0;
}

void StackDestroy(Stack* ps)//销毁栈
{
	assert(ps);
	ps->_capacity =  0;
	ps->_top = 0;
	free(ps->_a);
	ps->_a = NULL;
}

二、队列的相关概念

1．队列

一种特殊的线性表，只允许在一端插入数据，在另一端删除数据，栈中的元素遵循先进先出的原则

2．队头（对应链表头节点）：出队列的一侧

3．队尾（对应链表尾节点）：入队列的一侧

4．队列的实现：用链表较优，原因是数据出队列需要头删，数组效率较低

（1）Queue.h

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

// 链式结构：表示队列 
typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

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

（2）Queue.c

#include"Queue.h"
// 初始化队列 
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

// 队尾入队列 
void QueuePush(Queue* pq, QDataType data)
{
	assert(pq);
	if (pq->phead == NULL)//空队列
	{
		QNode* newnode = (QNode*)malloc(sizeof(QNode));
		if (newnode == NULL)
		{
			perror("malloc failed!");
			return;
		}
		newnode->next = NULL;
		newnode->data = data;

		pq->phead = newnode;
		pq->ptail = pq->phead;
		pq->size++;
	}
	else
	{
		QNode* newnode = (QNode*)malloc(sizeof(QNode));
		if (newnode == NULL)
		{
			perror("malloc failed!");
			return;
		}
		newnode->next = NULL;
		newnode->data = data;

		pq->ptail->next = newnode;
		pq->ptail = newnode;
		pq->size++;
	}
}

// 队头出队列（头删）
void QueuePop(Queue* pq)
{
	assert(pq);
	if (pq->phead->next == NULL)//只有一个节点
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
		pq->size = 0;
	}
	else
	{
		QNode* del = pq->phead;
		pq->phead = pq->phead->next;
		free(del);
		del = NULL;
		pq->size--;
	}
}

// 获取队列头部元素 
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	return pq->phead->data;
}

// 获取队列队尾元素 
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	return pq->ptail->data;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* pq)
{
	return pq->size;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* pq)
{
	if (pq->size == 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

// 销毁队列 
void QueueDestroy(Queue* pq)
{
	QNode* pcur = pq->phead;
	while (pcur)
	{
		QNode* del = pcur;
		pcur = pcur->next;
		free(del);
		del = NULL;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

三、经典OJ：有效的括号

1、题目描述

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
(1)左括号必须用相同类型的右括号闭合。
(2)左括号必须以正确的顺序闭合。
(3)每个右括号都有一个对应的相同类型的左括号。

2、题目分析

（1）C语言的限制

由于C语言不直接提供栈，因此需要把我们自己实现的栈粘贴到解决方案当中

（2）思路分析

• 第一步：遇到的左括号全部入栈
• 第二步：如果遇到右括号，则把栈顶的左括号出栈，拿出来和右括号匹配
  

（3）代码实现

如果用C语言实现，请记得在本函数上方粘贴自己实现好的栈，在本函数中才可以调用相关接口~

bool isValid(char* s) 
{
    Stack stack;
    StackInit(&stack);
    while(*s!='\0')
    {
        if(*s=='('||*s=='['||*s=='{')
        {
            StackPush(&stack,*s);//左括号入栈
        }
        else//此时*s是右括号
        {
            if(stack._top == 0)//此时栈里面没有左括号
            {
                return false;
            }
            STDataType left=StackTop(&stack);//取出栈顶元素进行配对
            if((left=='('&&*s!=')')
            ||(left=='['&&*s!=']')
            ||(left=='{'&&*s!='}'))
            {
                return false;
            }
            else//配对成功，出栈
            {
                StackPop(&stack);
            }
        }
        s++;
    }
    if(stack._top>0)
    {
        return false;
    }
    return true;
}