数据结构-C语言实现链栈

栈：只允许在一段进行插入或删除的线性表

链栈：利用链式储存实现的栈

---

定义

typedef enum//定义bool类型
{
	FALSE,//0
	TRUE//1
}bool;

typedef struct LinkNode//定义链栈节点
{
	int data;
	struct LinkNode* next;
}*LiStack;

不带头结点实现

初始化函数

空栈时没有结点，栈顶直接指向NULL

bool InitLiStack(LiStack* pls)//不带头节点的初始化
{
    assert(pls);
	*pls = NULL;//不带头节点，初始化后没有元素，指向空
	return TRUE;
}

---

断空函数

由上面的初始化函数如下实现：

bool LiStackEmpty(LiStack pls)
{
	if (pls == NULL)
		return TRUE;
	else
		return FALSE;
}

---

入栈函数

新申请的空间放到表头的前面，然后将表头指向新申请的空间。要更改外部栈顶指向，需传入二级指针。

bool Push(LiStack* pls, int e)//结点由二级指针传入
{
	assert(pls);
	LiStack p = (LiStack)malloc(sizeof(struct LinkNode));
	p->data = e;
	p->next = (*pls);
	*pls = p;
	return TRUE;
}

---

出栈函数

建立一个新的p结点，和栈顶指向同一片空间，然后想栈顶指向更改为下一个节点，最后释放掉p，也就释放了原来的栈顶指向的节点。两个传入参数都是取地址。

bool Pop(LiStack* pls, int* e)//链栈的出栈，用e接收被删元素
{
    assert(pls && e);
	if ((*pls) == NULL)//判断空栈
	{
		return FALSE;
	}
	*e = (*pls)->data;//带出被删除元素
	LiStack p = (*pls);//建立p是为了释放
	(*pls) = p->next;//将栈顶指向下一个节点
	free(p);//释放原本的栈顶节点
	p = NULL;
	return TRUE;
}

---

获取栈顶元素

bool GetTop(LiStack pls,int* e)//用e接受栈顶元素
{
    assert(e);
	if (pls == NULL)//判断空栈
	{
		return FALSE;
	}
	*e = pls->data;
	return TRUE;
}

---

摧毁链栈

循环Pop函数中的核心部分，用栈顶指向的是否是NULL来判断循环是否结束

bool DestroyLiStack(LiStack* pls)//链栈的销毁，实现方式就是把上面pop的操作循环起来
{
    assert(pls);
	LiStack p;
	while(*pls)
	{
		p = (*pls);//建立p是为了释放
		(*pls) = p->next;//将栈顶指向下一个节点
		free(p);//释放原本的栈顶节点
	}
	p = NULL;
	return TRUE;
}

---

代码测试

int main()
{
	LiStack LS ;
	InitLiStack(&LS);
	int x = 0;
	int i = 0;
	for (i = 0; i < 10; i++)//循环入栈
	{
		Push(&LS, i);
	}
	for (i = 0; i < 6; i++)//循环出栈
	{
		Pop(&LS, &x);
	}
	int y = 0;
	GetTop(LS, &y);//1
	DestroyLiStack(&LS);//2
	return 0;
}

1：

2：

---

带头结点实现

把不带头结点的代码微调一下即可，核心思想是栈顶结点不动，改变栈顶结点的next指向

初始化函数

第一个结点不放数据，指向NULL

bool InitLiStack(LiStack* pls)
{
	LiStack p = (LiStack)malloc(sizeof(struct LinkNode));
	if (p == NULL)
	{
		return FALSE;
	}
	(*pls) = p;
	(*pls)->next = NULL;
}

---

断空函数

bool LiStackEmpty(LiStack pls)
{
	if (pls->next == NULL)//利用初始化的内容判断
		return TRUE;
	else
		return FALSE;
}

---

入栈函数

bool Push(LiStack* pls, int e)//传入的*pls为头结点，不存储数据
{
	assert(pls);
	LiStack p = (LiStack)malloc(sizeof(struct LinkNode));
	if (p == NULL)
		return FALSE;
	p->data = e;
	p->next = (*pls)->next;//更改next而不是（*pls）本身
	(*pls)->next = p;//更改next而不是（*pls）本身
	return TRUE;
}

---

出栈函数

bool Pop(LiStack* pls, int* e)//链栈的出栈，用e接收被删元素
{
	assert(pls && e);
	if (((*pls)->next) == NULL)//判断空栈
	{
		return FALSE;
	}
	*e = (*pls)->next->data;//带出被删除元素
	LiStack p = (*pls)->next;next而不是（*pls）本身
	(*pls)->next = p->next;//更改next而不是（*pls）本身
	free(p);//释放原本的栈顶节点
	p = NULL;
	return TRUE;
}

---

摧毁函数

这里的摧毁函数实现和不带头结点的是一样的，无论有没有头结点，摧毁的是整条链表

bool DestroyLiStack(LiStack* pls)//链栈的销毁，实现方式就是把上面pop的操作循环起来
{
	assert(pls);
	LiStack p;
	while(*pls)
	{
		p = (*pls);//建立p是为了释放
		(*pls) = p->next;//将栈顶指向下一个节点
		free(p);//释放原本的栈顶节点
	}
	p = NULL;
	

代码测试

int main()
{
	LiStack LS ;
	InitLiStack(&LS);
	int x = 0;
	int i = 0;
	for (i = 0; i < 10; i++)//循环入栈
	{
		Push(&LS, i);
	}
	for (i = 0; i < 6; i++)//循环出栈
	{
		Pop(&LS, &x);
	}
	int y = 0;
	GetTop(LS, &y);//1
	DestroyLiStack(&LS);//2
	return 0;
}

1：

2：