【C/数据结构】栈-优快云博客

栈的概念

栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素。进行数据插入和删除操作的一端称为栈顶，另外一端称为栈底。

栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

压栈：栈的插入操作叫做进栈/压栈/入栈。入数据在栈顶。

出栈：栈的删除操作叫做出栈。出数据也在栈顶。

栈的实现

栈可以使用数组或者链表进行实现，由于数组进行尾插和尾删较快，所以使用数组较为合适，数组唯一的弊端就是扩容，而链表每次添加数据都需要扩容。

如果使用链表，使用单链表即可，将单链表的头部当作栈顶，这样进行栈顶的删除和添加较为迅速。

静态栈

// 静态栈

#define N 10
struct Stack
{
	int a[N];
	int top;
};

实际使用中一般不会使用静态栈

动态栈

栈的结构体

// 动态栈
typedef int STDataType;
typedef struct Stack
{
	// 指向动态数组的指针
	STDataType* a;
	// 栈顶元素的下标
	STDataType top;
	// 容量
	size_t capatity;
}ST;

栈中需要包含3个元素，分别是指向数组的指针，栈顶元素的下标，栈的容量

初始化栈

// 初始化栈
void STInit(ST* ps)
{
	assert(ps);
	// 初始化容量设置成4个
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc fail!\n");
		return;
	}
	ps->capatity = 4;
	// 初始化元素的数据为空，栈顶元素的下标为-1；
	ps->top = -1;
}

初始化容量设置成4
初始化时，元素中没有数据，将指向栈顶元素的下标设置成 -1.

【注意】刚初始化数组的时候，此时访问栈顶元素，会越界访问

栈的销毁

// 栈的销毁
void STDestory(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->capatity = 0;
	ps->top = 0;
	ps->a = NULL;
}

此时会出现一个问题，销毁ps时，需要传递二级指针吗？

【答】不需要，ps这个指针虽然时传值拷贝过来的，但是传递的结构体却是地址。但是如果这个函数体里将ps = NULLl;置空,不会使实参置空，所以这个是没有意义的。

入栈

// 入栈
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	
	if (ps->top == ps->top)
	{
		ST* tmp = (STDataType* )realloc(ps->a, sizeof(STDataType) * ps->capatity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail!\n");
			return;
		}
		ps->a = tmp;
		tmp = NULL;
		ps->capatity *= 2;
	}
	ps->top++;
	ps->a[ps->top] = x;
}

入栈需要扩容，由于top指向的是栈顶元素的下标，所以需要先将top+1，再入栈

判断栈是否为空

// 判空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == -1;
}

由于top指的是栈顶元素的下标，没有元素的时候，top应该为-1

出栈

// 出栈
void STpop(ST* ps)
{
	assert(ps);
	// 如果栈为空
	assert(!STEmpty(ps));

	ps->top--;
}

出栈的时候，直接将top减一即可，但是需要注意栈为空的情况。

查找元素个数

// 元素个数
size_t STSize(ST* ps)
{
	assert(ps);

	return ps->top + 1;
}

元素个数等于下标元素+1

访问栈顶元素

// 访问栈顶元素
STDataType STTop(ST* ps)
{
	assert(ps);
	if (ps->top > 0)
	{
		return ps->a[ps->top];
	}
	else
	{
		perror("top fail\n");
		return INT_MIN;
	}	
}

访问栈顶元素的时候，需要防止访问空栈

栈的优点和缺点

优点

入栈和出栈效率高，时间复杂度为O(1)，仅仅操作栈顶元素
结构简单，容易实现，底层可以是数组或者链表

缺点

无法随机访问中间元素，如果想要访问元素比较依次将数据从栈顶弹出
基于数组实现的栈存在容量限制，扩容时需要重新分配元素
基于链表实现的栈每一个结点都需要存储指针，空间开销较大。

栈的代码实现

Stack.h头文件

#ifndef STACK_H_
#define STACK_H_
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

// 静态栈
//#define N 10
//struct Stack
//{
//	int a[N];
//	int top;
//};

// 动态栈
typedef int STDataType;
typedef struct Stack
{
	// 指向动态数组的指针
	STDataType* a;
	// 栈顶元素的下标
	STDataType top;
	// 容量
	size_t capatity;
}ST;

// 初始化栈
void STInit(ST* ps);
// 栈的销毁
void STDestory(ST* ps);
// 入栈
void STPush(ST* ps, STDataType x);
// 判空
bool STEmpty(ST* ps);
// 出栈
void STpop(ST* ps);
// 元素个数
size_t STSize(ST* ps);


// 访问栈顶元素
STDataType STTop(ST* ps);



#endif // !STACK_H_

Stack.c源文件

#include"Stack.h"

// 初始化栈
void STInit(ST* ps)
{
	assert(ps);
	// 初始化容量设置成4个
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc fail!\n");
		return;
	}
	ps->capatity = 4;
	// 初始化元素的数据为空，栈顶元素的下标为-1；
	ps->top = -1;
}

// 栈的销毁
void STDestory(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->capatity = 0;
	ps->top = 0;
	ps->a = NULL;
}

// 入栈
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	
	if (ps->top == ps->top)
	{
		ST* tmp = (STDataType* )realloc(ps->a, sizeof(STDataType) * ps->capatity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail!\n");
			return;
		}
		ps->a = tmp;
		tmp = NULL;
		ps->capatity *= 2;
	}
	ps->top++;
	ps->a[ps->top] = x;
}

// 判空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == -1;
}

// 出栈
void STpop(ST* ps)
{
	assert(ps);
	// 如果栈为空
	assert(!STEmpty(ps));

	ps->top--;
}

// 元素个数
size_t STSize(ST* ps)
{
	assert(ps);

	return ps->top + 1;
}

// 访问栈顶元素
STDataType STTop(ST* ps)
{
	assert(ps);
	if (ps->top > 0)
	{
		return ps->a[ps->top];
	}
	else
	{
		perror("top fail\n");
		return INT_MIN;
	}	
}