线性结构（四）栈及其代码实现及OJ题

系列文章目录

线性结构（一）顺序表及其代码实现
线性结构（二）单链表及其代码实现
线性结构（三）头结点的循环双链表
线性结构（四）栈及其代码实现及OJ题

---

前言

栈也是很重要的一种线性数据结构，注意与操作系统中的栈进行区分，以及合理选择其物理结构。

---

1.栈

1.1 栈的介绍

栈，一种线性结构，要求只能在栈顶插入、删除数据，数据元素遵从“Last In First Out”，也即LIFO.
对于这一点可能会考察一种题目，也即多个数据元素出栈的顺序问题，因为多个数据元素可以边出边进，因此可能性有很多，一般考察从选型中选出不可能出现的出栈顺序。比如1、2、3依次入栈的话，出栈的顺序可能有1、2、3；1、3、2；2、3、1；3、2、1一共四种可能。

栈的实现，可以是顺序存储，也可以是链式存储。
我们数据操作都是在CPU上的，速度较快；数据存储在内存中，速度较慢，但价格较为低廉。处理数据要从内存中读取数据到CPU中，但二者相差速度过大，因此有一个缓冲区，CPU从缓冲区中读取数据，缓冲区从内存中读取数据，缓冲区的运行速度在二者之间。每次读取数据就像动态顺序存储一样，如果每次只读取所需要的4个字节，每访问4个字节就要读取一次，效率太低；因此每次读取内存的时候，都会读取所需数据及周围的数据，因为其周围的数据很可能很快就要用到。从这个角度看的话，栈使用顺序动态存储会好一点，因为如果是链式存储的话，每次多读取的数据，不仅没用上，还会导致CPU原本就不大的内存被污染，因为CPU是有限的，有新的数据进，就要有旧的数据出。
因此栈考虑用动态顺序存储实现。

对于出现在不同学科但相同的名词堆和栈的辨析如下

assert断言的好处是，OJ题中，如果有是assert的部分出错，会报在哪个地方出的错，方便查找。但没有的话，一般都是内存错误，无论是调试还是查找都不是很简单。

1.2 栈的代码实现

Stack.h

#pragma once
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST* ps);//初始化
void STDestroy(ST* ps); //销毁
void STPush(ST* ps,STDataType x);//增
void STPop(ST* ps);//删
bool STEmpty(ST* ps);//判空
int STSize(ST* ps);//求栈的元素个数
STDataType STTop(ST* ps);//求栈顶元素

Stack.c

#include "Stack.h"
void STInit(ST* ps)
{
	assert(ps);//不可能为空的指针要断言
	if (ps == NULL)
	{
		perror("malloc failed");
		return;
	}
	ps->a = (STDataType*)malloc(sizeof(ST) * 4);//初始化开辟4个元素的大小
	ps->capacity = 4;
	ps->top = 0;//top是栈顶元素的下一个位置
}
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)//如果栈满了要扩容
	{
		STDataType* tmp = (STDataType*)realloc(ps->a,sizeof(ST) * ps->capacity * 2);//一般扩容为原来的2倍
		if (tmp == NULL)
		{
			perror("realloc failed");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
	ps->a[ps->top++] = x;
}
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	ps->top--;
}
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->a[ps->top - 1];
}

Test.c

#include "Stack.h"
void TestStack()
{
	ST st;
	STInit(&st);
	STPush(&st, 1);
	while (!STEmpty(&st))
	{
		printf("%d ", STTop(&st));
		STPop(&st);//栈的特性要求，只能访问栈顶元素，因此要一边访问，一边出栈
	}
	STDestroy(&st);//记得在程序结束前销毁动态开辟的栈，否则导致内存泄露
}
int main()
{
	TestStack();
	return 0;
}

1.3 用栈解OJ题

20.有效的括号

这个题的思路是，对字符串的每个字符进行判断，

1. 如果为左括号就入栈，右括号就与出栈的左括号进行匹配，如果不匹配直接返回false；如果匹配，接着循环上述步骤。
2. 但是，在读取栈顶元素之前，一定要判定栈是否为空。如果为空，说明左括号还没出现就有了右括号，直接返回false；
3. 最后，如果栈为空，全部匹配，返回true；如果非空，说明左括号多，返回false.
4. 并且注意，程序结束前一定要销毁动态开辟的栈，否则造成内存泄漏。

typedef char STDataType;//题目的数据类型是char
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST* ps);
void STDestroy(ST* ps); 
void STPush(ST* ps,STDataType x);
void STPop(ST* ps);
bool STEmpty(ST* ps);
int STSize(ST* ps);
STDataType STTop(ST* ps);

void STInit(ST* ps)
{
	assert(ps);
	if (ps == NULL)
	{
		perror("malloc failed");
		return;
	}
	ps->a = (STDataType*)malloc(sizeof(ST) * 4);
	ps->capacity = 4;
	ps->top = 0;
}
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a,sizeof(ST) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc failed");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
	ps->a[ps->top++] = x;
}
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	ps->top--;
}
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->a[ps->top - 1];
}
bool isValid(char* s) {
    ST st;
    STInit(&st);
    while(*s)
    {
        if(*s=='(' || *s=='['||*s=='{')
            STPush(&st,*s);
        else
        {   if(STEmpty(&st))
            {
                //右括号出现，但左括号未出现
                STDestroy(&st);
                return false;
            }
            char top=STTop(&st);
            STPop(&st);
            if((*s==')' &&top!='(')
            || (*s==']' &&top!='[')
            || (*s=='}' &&top!='{') )
            {
                //左右不匹配
                STDestroy(&st);
                return false;
            }
        }
        s++;
    }
    //左括号多于右括号，且右括号均能匹配
    bool ret=STEmpty(&st);
    STDestroy(&st);
    return ret;
}

---

总结

数据结构其实很灵活，栈只要求LIFO，但实现方式可以灵活，但要根据实际情况进行选择；写代码时注意内存泄漏问题。