链栈的概念及实现（单链表实现）

概念

链栈是一种基于链表实现的栈结构。与顺序栈不同，链栈使用链式存储结构，每个栈元素都由一个节点组成。链栈的定义中包括栈顶指针和栈元素个数,栈中的元素按照后进先出的顺序存储。

相比于顺序栈

• 优点 ：对于空间的利用率比较高，可以根据实际情况动态调整栈的大小，避免了顺序栈可能出现的内存溢出等问题。同时，链栈的入栈和出栈操作只需要改变栈顶指针的指向，时间复杂度为 O(1)，不需要像顺序栈一样进行数据的移动,具有比较高的效率。

• 缺点：需要额外的指针存储空间，因此占用的存储空间较大。同时，由于链栈的存储结构是链式的，因此访问链栈的任意元素的时间复杂度为 O(n)，而顺序栈则可以通过下标直接访问任意元素，时间复杂度为 O(1)。

---

 实现

链表结构的选择

数据结构链栈的链表结构可以用单向链表、双向链表或循环链表来实现，不同的实现方式会影响链栈的操作效率、空间复杂度和代码实现难度等方面。

• 单向链表是链栈的最基本实现方式，每个节点只有一个指针域指向下一个节点，插入和删除节点的操作比较简单，但是访问链表中任意一个节点的时间复杂度为O(n)，性能较差。

• 双向链表在单向链表的基础上增加了一个指向前一个节点的指针域，这样可以双向遍历链表，访问任意一个节点的时间复杂度为O(1)，但是每个节点需要额外的一个指针域，增加了空间复杂度。

• 循环链表的尾节点指针指向头节点，形成一个环形结构，这样可以省去判断链表是否为空的操作，并且可以方便地实现栈的循环利用，但是需要特殊处理一些边界情况，如头结点的处理。

综上所述，对于链栈的实现，单向链表是最基本、最简单的实现方式，但是由于访问节点的时间复杂度较高，不适用于大规模数据存储的场景；双向链表可以提高访问节点的效率，但是空间复杂度相应增加；循环链表可以省去判断链表是否为空的操作，但是需要特殊处理一些边界情况。

单链表实现栈

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

typedef int LinkStackType;

typedef struct LinkStackNode
{
	LinkStackType data;          //数据域
	struct LinkStackNode* next;  //指针域
}LinkStackNode;

typedef struct LinkStack
{
	LinkStackNode* guard;        //带哨兵位的头节点
	int capacity;                //栈的元素个数
}LStack;

//链栈初始化
void LinkStackInit(LStack* p)
{
	assert(p);
	p->guard = (LinkStackNode*)malloc(sizeof(LinkStackNode));
	if (p->guard == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	p->guard->next = NULL;
	p->capacity = 0;
}

//链栈销毁
void LinkStackDestroy(LStack* p)
{
	assert(p);
	while (p->guard)
	{
		LinkStackNode* del = p->guard;
		p->guard = p->guard->next;
		free(del);
	}
	p->capacity = 0;
}

//链栈判空
bool LinkStackEmpty(LStack* p)
{
	assert(p);
	return p->capacity == 0;
}

//入栈
void LinkStackPush(LStack* p, LinkStackType x)
{
	assert(p);
	LinkStackNode* newNode = (LinkStackNode*)malloc(sizeof(LinkStackNode));
	if (newNode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newNode->data = x;
	newNode->next = p->guard->next;
	p->guard->next = newNode;
	p->capacity++;
}

//出栈
void LinkStackPop(LStack* p)
{
	assert(p);
	assert(!LinkStackEmpty(p));
	LinkStackNode* del = p->guard->next;
	p->guard->next = p->guard->next->next;
	free(del);
	p->capacity--;
}

//返回栈顶元素
LinkStackType LinkStackTop(LStack* p)
{
	assert(p);
	assert(!LinkStackEmpty(p));
	return p->guard->next->data;
}

//返回链栈元素个数
int LinkStackSize(LStack* p)
{
	assert(p);
	return p->capacity;
}

以上代码为链栈基本功能的实现，如果有额外需求，可以根据栈的特性自行实现。

如果有疑问或者有错，欢迎评论区指正，有看必回。