2022.4.9 链栈

1. 链栈
   链栈：是在单链表的基础上进行操作
   用单链表的头插和头删代替表尾进行插入和删除
2. 链栈结构体设计

typedef int ELEM_TYPE;

typedef struct LStack
{
	ELEM_TYPE data;
	struct LStack* next;
}LStack,*PLStack;

list-stack.h文件

//链栈可执行函数声明
//初始化
void Init_LStack(struct LStack* ps);

//入栈(插入)
bool Push(PLStack ps, ELEM_TYPE val);

//出栈（获取栈顶元素值）
bool Pop(PLStack ps, ELEM_TYPE* rtval); 

//获取栈顶元素(获取栈顶元素值)
bool Top(PLStack ps, ELEM_TYPE* rtval);

//判空
bool Isempty(PLStack ps);

//获取有效长度
int Get_length(PLStack ps);

//清空
void Clear(PLStack ps);

//销毁
void Destroy(PLStack ps);

//打印
void Show(PLStack ps);

注意，不需要判满和扩容，因为链栈空间是无限的
list_stack.cpp文件

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include"list_stack.h"

//初始化
void Init_LStack(struct LStack * ps)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return;
	}
	ps->next = NULL;//链式栈用的单链表的
}

//入栈(插入)
bool Push(PLStack ps, ELEM_TYPE val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	//1.购买新节点
	struct LStack* pnewnode = (PLStack)malloc(1 * sizeof(struct LStack));
	assert(pnewnode != NULL);
	pnewnode->data = val;

	//2.找到合适的插入位置（头插不用管，因为头结点就是合适位置）
	//3.进行插入
	pnewnode->next = ps->next;
	ps->next = pnewnode;
	return true;
}

//出栈(获取栈顶元素值，并且删除)
bool Pop(PLStack ps, ELEM_TYPE* rtval)//rtval是输出参数
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	if (Isempty(ps))//确定链栈至少有一个节点
	{
		return false;
	}
	*rtval = ps->next->data;//ps->next是首元素，将一会要出栈的值通过输出参数带出来

	//申请一个临时指针指向待删除节点，跨越指向，释放待删除节点
	struct LStack* p = ps->next;
	ps->next = p->next;//跨越指向
	free(p);
	return true;
}

//获取栈顶元素
bool Top(PLStack ps, ELEM_TYPE* rtval)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	if (Isempty(ps))//确定链栈至少有一个节点
	{
		return false;
	}
	*rtval = ps->next->data;//ps->next是首元素，将一会要出栈的值通过输出参数带出来
	return true;
}
//判空
bool Isempty(PLStack ps)
{
	return ps->next == NULL;
}

//获取有效长度
int Get_length(PLStack ps)
{
	int count = 0;
	//只要调用我们之前写的不需要前驱的for循环，遍历一遍即可
	struct LStack* p = ps->next;
	for (p; p != NULL; p = p->next)
	{
		count++;
	}
	//需要前驱的for循环，p指向头结点(p->ps)，不需要前驱的for循环，p指向首元素的地址(即p=ps->next);
	return count;
}

//清空
void Clear(PLStack ps)//对于链式结构来说，清空就是调用销毁
{
	Destroy(ps);
}

//销毁
void Destroy(PLStack ps)
{
	//第二种销毁方式
	PLStack p = ps->next;
	PLStack q = NULL;

	ps->next = NULL;
	while (p != NULL)
	{
		q = p->next;
		free(p);
		p = q;
	}

}

//打印
void Show(PLStack ps)
{
	struct LStack* p = ps->next;
	for (p; p != NULL; p = p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}

主函数文件.cpp

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"list_stack.h"//头结点不区分大小写

//链栈
int main()
{
	struct LStack head;
	Init_LStack(&head);
	for (int i = 0; i < 20; i++)//链栈无限长度
	{
		Push(&head, i+1);
	}
	Show(&head);
	printf("length=%d\n", Get_length(&head));

	ELEM_TYPE tmp;
	bool tag1 = Pop(&head, &tmp);
	if (tag1)
	{
		printf("%d\n", tmp);
	}
	Show(&head);
	printf("length=%d\n", Get_length(&head));

	ELEM_TYPE flg;
	bool tag2 = Top(&head, &flg);
	if (tag2)
	{
		printf("%d\n", flg);
	}
	Show(&head);
	printf("length=%d\n", Get_length(&head));
    Clear(&head);
    Destroy(&head);
	return 0;
}

运行结果：