数据结构——线性表（栈）

数据结构线性表（栈）

今天给大家分享一些关于栈的基本知识和相关功能接口实现。

栈

1.概念

栈：一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。进行插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的元素遵守后进先出的原则。
压栈：占的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈，出数据也在栈顶。

2.结构

3.栈的实现

栈的实现一般使用数组或者链表实现。

3.1顺序栈

类似于顺序表借助数组实现。

3.1.1结构

#define SEQ_STACK_DEFAULT_SIZE 8
#define SEQ_STACK_INC_SIZE     3

typedef struct SeqStack
{
	ElemType *base;
	size_t   capacity;
	int       top;
}SeqStack;

3.1.2接口实现

主要实现顺序栈的初始化、扩容、判空、判满、入栈、出栈、取栈顶元素、打印、摧毁操作。

void SeqStackInit(SeqStack *pst);//初始化
static bool _StackInc(SeqStack *pst);//扩容
bool SeqStackIsFull(SeqStack *pst);//判满
bool SeqStackIsEmpty(SeqStack *pst);//判空
void SeqStackPush(SeqStack *pst,ElemType x);//入栈
void SeqStackPop(SeqStack *pst);//出栈
ElemType SeqStackTop(SeqStack *pst);//取栈顶元素
void SeqStackPrint(SeqStack *pst);//打印
void SeqStackDestory(SeqStack *pst);//摧毁

3.1.3初始化

void SeqStackInit(SeqStack *pst)
{
	pst->base = (ElemType*)malloc(sizeof(ElemType)*SEQ_STACK_DEFAULT_SIZE);
	assert(pst->base != NULL);
	pst->capacity = SEQ_STACK_DEFAULT_SIZE;
	pst->top = 0;  //-1
}

3.1.4扩容

static bool _StackInc(SeqStack *pst)
{
	ElemType *new_base = (ElemType*)realloc(pst->base, sizeof(ElemType)*(pst->capacity+SEQ_STACK_INC_SIZE));
	if (new_base == NULL)
		return false;
	pst->base = new_base;
	pst->capacity += SEQ_STACK_INC_SIZE;
	return true;
}

3.1.5判满

bool SeqStackIsFull(SeqStack *pst)
{
	assert(pst != NULL);
	return pst->top >= pst->capacity;
}

3.1.6判空

bool SeqStackIsEmpty(SeqStack *pst)
{
	assert(pst != NULL);
	return pst->top == 0;
}

3.1.7入栈

void SeqStackPush(SeqStack *pst, ElemType x)
{
	assert(pst != NULL);
	if (SeqStackIsFull(pst) && !_StackInc(pst))
	{
		printf("栈空间已满，%d不能入栈.\n",x);
		return;
	}
	pst->base[pst->top++] = x;
}

3.1.8出栈

void SeqStackPop(SeqStack *pst)
{
	assert(pst != NULL);
	if (SeqStackIsEmpty(pst))
	{
		printf("栈已空，不能出栈.\n");
		return;
	}
	pst->top--;
}

3.1.9取栈顶元素

ElemType SeqStackTop(SeqStack *pst)
{
	assert(pst != NULL);
	if (SeqStackIsEmpty(pst))
	{
		printf("栈已空，不能取栈顶元素.\n");
		return;
	}
	return pst->base[pst->top - 1];
}

3.1.10打印

void SeqStackPrint(SeqStack *pst)
{
	assert(pst != NULL);
	for (int i = pst->top - 1; i >= 0;--i)
		printf("%d\n",pst->base[i]);
	printf("\n");

}

3.1.11摧毁

void SeqStackDestory(SeqStack *pst)
{
	assert(pst != NULL);
	free(pst->base);
	pst->base = NULL;
	pst->capacity = pst->top = 0;
}

3.1.12测试

#include"stack.h"
//顺序栈主函数
void main()
{
	SeqStack st;
	SeqStackInit(&st);
	SeqStackPush(&st, 1);
	SeqStackPush(&st, 2);
	SeqStackPush(&st, 3);
	SeqStackPush(&st, 4);
	SeqStackPush(&st, 5);
	SeqStackPush(&st, 6);
	SeqStackPush(&st, 7);
	SeqStackPush(&st, 8);
	SeqStackPush(&st, 9);
	SeqStackPrint(&st);

	ElemType val = SeqStackTop(&st);
	SeqStackPop(&st);
	printf("%d 出栈.\n", val);

	val = SeqStackTop(&st);
	SeqStackPop(&st);
	printf("%d 出栈.\n", val);
	SeqStackPrint(&st);
	SeqStackDestory(&st);
}

测试结果：

3.2链栈

借助链表实现。

3.2.1结构

typedef struct LinkStackNode
{
	ElemType data;
	struct LinkStackNode *link;
}LinkStackNode;

typedef struct LinkStack
{
	LinkStackNode *top;
}LinkStack;

3.2.2接口实现

主要实现链栈的初始化、入栈、出栈、取栈顶元素、打印、摧毁操作。

void LinkStackInit(LinkStack *pst);//初始化
void LinkStackPush(LinkStack *pst,ElemType x);//入栈
void LinkStackPop(LinkStack *pst);//出栈
ElemType LinkStackTop(LinkStack *pst);//取栈顶元素
void LinkStackPrint(LinkStack *pst);//打印
void LinkStackDestory(LinkStack *pst);//摧毁

3.2.3初始化

void LinkStackInit(LinkStack *pst)
{
	assert(pst != NULL);
	pst->top = NULL;
}

3.2.4入栈

void LinkStackPush(LinkStack *pst, ElemType x)
{
	assert(pst != NULL);
	LinkStackNode *node = (LinkStackNode*)malloc(sizeof(LinkStackNode));
	assert(node != NULL);
	node->data = x;
	node->link = pst->top;
	pst->top = node;
}

3.2.5出栈

void LinkStackPop(LinkStack *pst)
{
	assert(pst != NULL);
	LinkStackNode *p = pst->top;
	pst->top = p->link;
	free(p);
}

3.2.6取栈顶元素

ElemType LinkStackTop(LinkStack *pst)
{
	assert(pst != NULL);
	if (pst->top == NULL)
	{
		printf("栈已空，不能取栈顶元素.\n");
		return;
	}
	return pst->top->data;
}

3.2.7打印

void LinkStackPrint(LinkStack *pst)
{
	assert(pst != NULL);
	LinkStackNode *p = pst->top;
	while (p != NULL)
	{
		printf("%d\n",p->data);
		p = p->link;
	}
	printf("\n");
}

3.2.8摧毁

void LinkStackDestory(LinkStack *pst)
{
	assert(pst != NULL);
	while (pst->top != NULL)
	{
		LinkStackNode *p = pst->top;
		pst->top = p->link;
		free(p);
	}
}

3.2.9测试

#include"stack.h"
//链栈主函数
void main()
{
	LinkStack st;
	LinkStackInit(&st);
	LinkStackPush(&st, 1);
	LinkStackPush(&st, 2);
	LinkStackPush(&st, 3);
	LinkStackPush(&st, 4);
	LinkStackPush(&st, 5);
	LinkStackPush(&st, 6);
	LinkStackPrint(&st);

	ElemType val = LinkStackTop(&st);
	LinkStackPop(&st);
	printf("%d 出栈.\n",val);

	val = LinkStackTop(&st);
	LinkStackPop(&st);
	printf("%d 出栈.\n", val);
	LinkStackPrint(&st);

	LinkStackDestory(&st);
}

测试结果：

希望这些知识对你有用哦！
感谢浏览！阿里嘎都
如果能点赞的话那就更好啦！