链式队列-基础数据结构

链式队列有很多内容也是和单链表通用的

先写链式队列的头文件list_Stack.h

#pragma once

//链式栈的结构体声明：直接用单链表即可
typedef int ELEM_TYPE;

//有效数据节点结构体设计（头结点借用）
typedef struct LStack
{
	ELEM_TYPE data;//数据域   （1.头结点：不保存任何数据    2.有效数据节点：保存有效值）   
	struct LStack* next;//指针域  (1.头结点：保存第一个元素的地址    2.有效数据节点：保存下一个有效元素的地址)
}LStack, * PLStack;

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

//入栈（插入）
bool Push(struct LStack* ps, ELEM_TYPE val);

//出栈（获取栈顶元素，并且删除）用到一个输出参数
bool Pop(struct LStack* ps, ELEM_TYPE* rtval);

//获取栈顶元素（获取栈顶元素，但不删除）
bool Top(struct LStack* ps, ELEM_TYPE* rtval);

//判空
bool IsEmpty(struct LStack* ps);

//判满
//bool IsFull(struct LStack* ps);

//获取有效长度
int Get_length(struct LStack* ps);

//清空
void Clear(struct LStack* ps);

//销毁
void Destroy(struct LStack* ps);

//打印
void Show(struct LStack* ps);

接着写list_Stack.cpp文件

#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#include<stdlib.h>
#include"list_Stack.h"

//初始化
void Init_lstack(struct LStack* ps)
{
	assert(ps != NULL);
	if (NULL == ps)
	{
		return;
	}
	ps->next = NULL;
}

//入栈（头插）
bool Push(struct LStack* ps, ELEM_TYPE val)
{
	//assert
	//1.购买新节点
	struct LStack* pnewnode = (struct LStack*)malloc(1 * sizeof(struct LStack));
	assert(pnewnode != NULL);
	pnewnode->data = val;
	pnewnode->next = NULL;
	//2.找到合适的插入位置(头插不用找因为头结点就是合适位置)

	//3.进行插入
	pnewnode->next = ps->next;
	ps->next = pnewnode;

	return true;
}

//出栈（获取栈顶元素，并且删除）用到一个输出参数
bool Pop(struct LStack* ps, ELEM_TYPE* rtval)
{
	//assert (ps   rtval) !=NULL
	//出栈需要判空
	if (IsEmpty(ps)) //确定至少存在一个节点
	{
		return false;
	}

	*rtval = ps->next->data;

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

//获取栈顶元素（获取栈顶元素，但不删除）
bool Top(struct LStack* ps, ELEM_TYPE* rtval)
{
	//assert (ps   rtval) !=NULL
	//出栈需要判空
	if (IsEmpty(ps)) //确定至少存在一个节点
	{
		return false;
	}

	*rtval = ps->next->data; //将一定要出栈的值，通过输出参数rtval带出来
	
	return true;

}

//判空
bool IsEmpty(struct LStack* ps)
{
	//assert

	return ps->next == NULL;
}

//判满 不用判满

//获取有效长度
int Get_length(struct LStack* ps)
{
	//assert
	int count = 0;
	for (PLStack p = ps->next; p != NULL ; p = p->next)
	{
		count++;
	}
	return count;
}

//清空
void Clear(struct LStack* ps)
{
	Destroy(ps);
}

//销毁
void Destroy(struct LStack* ps)
{
	struct LStack* p = ps->next;
	struct LStack* q = NULL;

	ps->next = NULL;

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

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

最后在主函数中测试代码的正确性：

#include<stdio.h>
#include <stdlib.h>
#include<assert.h>
#include<vld.h>
#include"list_Stack.h"

//链式栈的测试用例
int main()
{
	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("pop = %d\n", tmp);
	}
	Show(&head);
	printf("length = %d\n", Get_length(&head));

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

	Destroy(&head);
	return 0;
}

运行结果如下：