第三部分—数据结构与算法基础_3. 受限线性表

3.1栈(Stack)

3.1.1栈的基本概念

概念：

首先它是一个线性表，也就是说，栈元素具有线性关系，即前驱后继关系。只不过它是一种特殊的线性表而已。定义中说是在线性表的表尾进行插入和删除操作，这里表尾是指栈顶，而不是栈底。

特性

它的特殊之处在于限制了这个线性表的插入和删除的位置，它始终只在栈顶进行。这也就使得：栈底是固定的，最先进栈的只能在栈底。

操作
1. 栈的插入操作，叫做进栈，也叫压栈。类似子弹入弹夹（如下图所示）
2. 栈的删除操作，叫做出栈，也有的叫做弾栈，退栈。如同弹夹中的子弹出夹（如下图所示）

3.1.2栈的顺序存储

基本概念

栈的顺序存储结构简称顺序栈，它是运算受限制的顺序表。顺序栈的存储结构是：利用一组地址连续的的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top只是栈顶元素在顺序表中的位置。

设计与实现

因为栈是一种特殊的线性表，所以栈的顺序存储可以通过顺序表来实现。

3.1.3代码实现

1.创建三个文件

2.代码


//1.Stack_BySequenceList_Head.h 部分
 
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define MAX 1024
typedef void* pSeqStack;
 
//1.定义栈结构体
struct Stack
{
	//栈的数组
	void* data[MAX];
	//栈大小
	int Size;
};
 
 
 
//2.初始化函数声明
pSeqStack InitSeqStack();
 
 
 
//3.入栈函数声明
void PushSeqStack(pSeqStack stack, void* data);
 
 
 
//4.出栈函数声明
void PopSeqStack(pSeqStack stack);
 
 
 
//5.返回栈大小函数声明
int SeqStackSize(pSeqStack stack);
 
 
 
//6.判断栈是否为空函数声明
int IsEmptyStackSize(pSeqStack stack);
 
 
 
//7.返回栈顶元素函数声明
void* TopStackSize(pSeqStack stack);
 
 
 
//8.销毁栈函数声明
void DestroyStackSize(pSeqStack stack);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
//2.Stack_BySequenceList_Function.c 部分
 
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include"Stack_BySequenceList_Head.h"
 
 
 
//2.初始化函数实现
pSeqStack InitSeqStack()
{
	struct Stack* myStack = malloc(sizeof(struct Stack));
	if (myStack == NULL)
	{
		return NULL;
	}
 
	//初始化数组
	memset(myStack->data, 0, sizeof(void*) * MAX);
	//初始化栈大小
	myStack->Size = 0;
	return myStack;
}
 
 
 
//3.入栈函数实现
void PushSeqStack(pSeqStack stack, void* data)
{
	//入栈本质——数组尾插
	if (stack == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	struct Stack* mystack = stack;
	if (mystack->Size == MAX)
	{
		return;
	}
 
	mystack->data[mystack->Size] = data;
	mystack->Size++;
}
 
 
 
//4.出栈函数实现
void PopSeqStack(pSeqStack stack)
{
	//出栈本质——数组尾删
	if (stack == NULL)
	{
		return;
	}
	struct Stack* mystack = stack;
	if (mystack->Size == 0)
	{
		return;
	}
	mystack->data[mystack->Size - 1] = NULL;
	mystack->Size--;
}
 
 
 
 
//5.返回栈大小函数实现
int SeqStackSize(pSeqStack stack)
{
	if (stack == NULL)
	{
		return -1;
	}
	struct Stack* mystack = stack;
	return mystack->Size;
}
 
 
 
 
//6.判断栈是否为空函数实现
int IsEmptyStackSize(pSeqStack stack)
{
	if (stack == NULL)
	{
		//返回-1代表栈不存在
		return -1;         
	}
	struct Stack* mystack = stack;
	if (mystack->Size == 0)
	{
		//返回1代表栈为空
		return 1;
	}
	//返回0代表栈不为空
	return 0;
}
 
 
 
 
//7.返回栈顶元素函数声明
void* TopStackSize(pSeqStack stack)
{
	if (stack == NULL)
	{
		return NULL;
	}
	struct Stack* mystack = stack;
	if (mystack->Size == 0)
	{
		return NULL;
	}
	return mystack->data[mystack->Size - 1];
}
 
 
 
 
//8.销毁栈函数实现
void DestroyStackSize(pSeqStack stack)
{
	if (stack == NULL)
	{
		return;
	}
	free(stack);
	stack = NULL;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
//3.Stack_BySequenceList_Main.c 部分
 
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include"Stack_BySequenceList_Head.h"
 
 
//测试
 
//1.定义数据结构体
struct Person
{
	char name[64];
	int age;
};
 
 
int main()
{
	//初始化栈
	pSeqStack myStack = InitSeqStack();
 
	//创建数据
	struct Person p1 = { "aaa", 10 };
	struct Person p2 = { "bbb", 20 };
	struct Person p3 = { "ccc", 30 };
	struct Person p4 = { "ddd", 40 };
	struct Person p5 = { "eee", 50 };
 
	//入栈
	PushSeqStack(myStack, &p1);
	PushSeqStack(myStack, &p2);
	PushSeqStack(myStack, &p3);
	PushSeqStack(myStack, &p4);
	PushSeqStack(myStack, &p5);
 
	printf("栈的元素个数为：%d\n", SeqStackSize(myStack));
 
	//栈不为空则查看栈顶元素再出栈
	while (IsEmptyStackSize(myStack) == 0) 
	{
		struct Person* p = TopStackSize(myStack);
		printf("姓名：%s 年龄：%d\n", p->name, p->age);
		//出栈
		PopSeqStack(myStack);
	}
 
	printf("栈的元素个数为：%d\n", SeqStackSize(myStack));
 
	//销毁栈
	DestroyStackSize(myStack);
	return 0;
}

3.1.3栈的链式存储

基本概念

栈的链式存储结构简称链栈。

思考如下问题：

栈只是栈顶来做插入和删除操作，栈顶放在链表的头部还是尾部呢？

由于单链表有头指针，而栈顶指针也是必须的，所以比较好的办法就是把栈顶放在单链表的头部。另外都已经有了栈顶在头部了，单链表中比较常用的头结点也就失去了意义，通常对于链栈来说，是不需要头结点的。

设计与实现

链栈是一种特殊的线性表，链栈可以通过链式线性表来实现。

3.1.4代码实现

1.创建三个文件

2.代码


//1.Stack_ByLinkedList_Head.h 部分
 
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
typedef void* pLinkedStack;
 
//1.定义指针结构体
struct StackNode
{
	struct StackNode* next;
};
 
 
 
//2.定义栈的结构体
struct LinkedStack
{
	struct StackNode pHeader;
	int Size;
};
 
 
 
//3.初始化栈函数声明
pLinkedStack InitLinkedStack();
 
 
 
//4.入栈函数声明
void PushLinkedStack(pLinkedStack stack, void* data);
 
 
 
//5.出栈函数声明
void PopLinkedStack(pLinkedStack stack);
 
 
 
//6.返回栈顶元素函数声明
void* TopLinkedStack(pLinkedStack stack);
 
 
 
//7.返回栈元素个数函数声明
int SizeLinkedStack(pLinkedStack stack);
 
 
 
//8.判断栈是否为空函数声明
int IsEmptyLinkedStack(pLinkedStack stack);
 
 
 
//9.栈销毁函数声明
void DestroyLinkedStack(pLinkedStack stack);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
//2.Stack_ByLinkedList_Function.c 部分
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include"Stack_ByLinkedList_Head.h"
 
 
//3.初始化栈函数实现
pLinkedStack InitLinkedStack()
{
	struct LinkedStack* mystack = malloc(sizeof(struct LinkedStack));
	if (mystack == NULL)
	{
		return NULL;
	}
	mystack->pHeader.next = NULL;
	mystack->Size = 0;
}
 
 
 
//4.入栈函数声实现
void PushLinkedStack(pLinkedStack stack, void* data)
{
	//入栈本质——链表头插
	if (stack == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	struct LinkedStack* mystack = stack;
 
	//将用户数据取出前4个字节
	struct StackNode* mynode = data;
 
	//更改指针指向
	mynode->next = mystack->pHeader.next;
	mystack->pHeader.next = mynode;
 
	//更新链表长度
	mystack->Size++;
}
 
 
 
//5.出栈函数声明
void PopLinkedStack(pLinkedStack stack)
{
	//出战本质——链表头删
	if (stack == NULL)
	{
		return;
	}
	struct LinkedStack* mystack = stack;
	if(mystack->Size==0)
	{
		return;
	}
 
	//更改指针指向
	mystack->pHeader.next = mystack->pHeader.next->next;
 
	//更新栈大小
	mystack->Size--;
}
 
 
 
//6.返回栈顶元素函数实现
void* TopLinkedStack(pLinkedStack stack)
{
	if (stack == NULL)
	{
		return;
	}
	struct LinkedStack* mystack = stack;
	if (mystack->Size == 0)
	{
		return;
	}
	return mystack->pHeader.next;
}
 
 
 
//7.返回栈元素个数函数实现
int SizeLinkedStack(pLinkedStack stack)
{
	if (stack == NULL)
	{
		//返回-1表示栈不存在
		return -1;
	}
	struct LinkedStack* mystack = stack;
	return mystack->Size;
}
 
 
 
//8.判断栈是否为空函数实现
int IsEmptyLinkedStack(pLinkedStack stack)
{
	if (stack == NULL)
	{
		//返回-1表示栈不存在
		return -1;
	}
	struct LinkedStack* mystack = stack;
	if (mystack->Size == 0)
	{
		//返回-1表示栈为空
		return 1;
	}
 
	//返回0表示栈不为空
	return 0;
}
 
 
 
//9.栈销毁函数实现
void DestroyLinkedStack(pLinkedStack stack)
{
	if (stack == NULL)
	{
		return;
	}
	free(stack);
	stack = NULL;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
//3.Stack_ByLinkedList_Main.c 部分
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include"Stack_ByLinkedList_Head.h"
 
 
 
//测试
struct Person
{
	void* node;
	char name[64];
	int age;
};
 
 
 
int main()
{
	//初始化栈
	pLinkedStack myStack = InitLinkedStack();
	//创建数据
	struct Person p1 = { NULL, "aaa", 10 };
	struct Person p2 = { NULL, "bbb", 20 };
	struct Person p3 = { NULL, "ccc", 30 };
	struct Person p4 = { NULL, "ddd", 40 };
	struct Person p5 = { NULL, "eee", 50 };
 
	//入栈
	PushLinkedStack(myStack, &p1);
	PushLinkedStack(myStack, &p2);
	PushLinkedStack(myStack, &p3);
	PushLinkedStack(myStack, &p4);
	PushLinkedStack(myStack, &p5);
	printf("链式存储-- 栈的元素个数为：%d\n", SizeLinkedStack(myStack));
	//栈不为空，查看栈顶元素，出栈
	while (IsEmptyLinkedStack(myStack) == 0) 
	{
		struct Person* p = TopLinkedStack(myStack);
		printf("姓名：%s 年龄：%d\n", p->name, p->age);
		//出栈
		PopLinkedStack(myStack);
	}
	printf("链式存储-- 栈的元素个数为：%d\n", SizeLinkedStack(myStack));
	//销毁栈
	DestroyLinkedStack(myStack);
	return 0;
}

3.2队列(Queue)

3.2.1队列基本概念

队列是一种特殊的受限制的线性表。

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出的t（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后。如下图：

3.2.3队列的顺序存储

基本概念

队列也是一种特殊的线性表；可以用线性表顺序存储来模拟队列。

1.创建三个文件

2.代码


//1.Queue_BySequence List_Head.h 部分
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define MAX 1024
typedef void* pSeqQueue;
 
 
//1.定义队列结构体
struct SeqQueue
{
	void** pQueue;
	int Capacity;
	int Size;
};
 
 
 
//2.初始化队列结构体函数声明
pSeqQueue InitSeqQueue(int capacity);
 
 
 
//3.入队列函数声明
void PushSeqQueue(pSeqQueue queue, void* data);
 
 
 
//4.出队列函数声明
void PopSeqQueue(pSeqQueue queue);
 
 
 
//5.返回队列大小函数声明
int SizeSeqQueue(pSeqQueue queue);
 
 
 
//6.判断队列是否为空函数声明
int IsEmptySeqQueue(pSeqQueue queue);
 
 
 
//7.返回对头元素函数声明
void* FrontSeqQueue(pSeqQueue queue);
 
 
 
//8.返回队尾元素函数声明
void* BackSeqQueue(pSeqQueue queue);
 
 
 
//9.销魂队列函数声明
void DestroySeqQueue(pSeqQueue queue);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
//2.Queue_BySequence List_Function.c 部分
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include"Queue_BySequence List_Head.h"
 
 
//2.初始化队列结构体函数实现
pSeqQueue InitSeqQueue(int capacity)
{
	if (capacity == 0)
	{
		return;
	}
	struct SeqQueue* myQueue = malloc(sizeof(struct SeqQueue));
	if (myQueue == NULL)
	{
		return NULL;
	}
	myQueue->pQueue = malloc(sizeof(void*) * capacity);
	myQueue->Capacity = capacity;
	myQueue->Size = 0;
	return myQueue;
}
 
 
 
 
//3.入队列函数声明
void PushSeqQueue(pSeqQueue queue, void* data)
{
	//入队列本——数组头插
	if (queue == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	struct SeqQueue* myQueue = queue;
	if (myQueue->Size == MAX)
	{
		return;
	}
	for (int i = myQueue->Size - 1; i >= 0; i--)
	{
		myQueue->pQueue[i + 1] = myQueue->pQueue[i];
	}
	myQueue->pQueue[0] = data;
	myQueue->Size++;
}
 
 
 
//4.出队列函数实现
void PopSeqQueue(pSeqQueue queue)
{
	//本质——尾删
	if (queue == NULL)
	{
		return;
	}
	struct SeqQueue* myQueue = queue;
	if (myQueue->Size == 0)
	{
		return;
	}
	myQueue->Size--;
}
 
 
 
//5.返回队列大小函数实现
int SizeSeqQueue(pSeqQueue queue)
{
	if (queue == NULL)
	{
		return -1;
	}
	struct SeqQueue* myQueue = queue;
	return myQueue->Size;
}
 
 
 
//6.判断队列是否为空函数实现
int IsEmptySeqQueue(pSeqQueue queue)
{
	if (queue == NULL)
	{
		//返回-1表示队列不存在
		return -1;
	}
	struct SeqQueue* myQueue = queue;
	if (myQueue->Size == 0)
	{
		//返回1表示队列为空
		return 1;
	}
	return 0;
}
 
 
 
//7.返回队头元素函数实现
void* FrontSeqQueue(pSeqQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}
	struct SeqQueue* myQueue = queue;
	return myQueue->pQueue[myQueue->Size - 1];
}
 
 
 
//8.返回队尾元素函数实现
void* BackSeqQueue(pSeqQueue queue)
{
	if(queue==NULL)
	{
		return NULL;
	}
	struct SeqQueue* myQueue = queue;
	return myQueue->pQueue[0];
}
 
 
 
//9.销魂队列函数实现
void DestroySeqQueue(pSeqQueue queue)
{
	if (queue == NULL)
	{
		return;
	}
	struct SeqQueue* myQueue = queue;
	free(myQueue->pQueue);
	myQueue->pQueue = NULL;
 
	free(myQueue);
	myQueue = NULL;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
//3.Queue_BySequence List_Main.c 部分
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include"Queue_BySequence List_Head.h"
 
 
 
//测试
 
//1.定义数据结构体
struct Person
{
	char name[64];
	int age;
};
 
 
int main()
{
	//初始化队列
	pSeqQueue myQueue = InitSeqQueue(MAX);
 
	//准备数据
	struct Person p1 = { "aaa", 10 };
	struct Person p2 = { "bbb", 20 };
	struct Person p3 = { "ccc", 30 };
	struct Person p4 = { "ddd", 40 };
 
 
	//入队
	PushSeqQueue(myQueue, &p1);
	PushSeqQueue(myQueue, &p2);
	PushSeqQueue(myQueue, &p3);
	PushSeqQueue(myQueue, &p4);
	printf("队列大小为：%d\n", SizeSeqQueue(myQueue));
	while (IsEmptySeqQueue(myQueue) == 0)
	{
		//访问队头
		struct Person* pFront = FrontSeqQueue(myQueue);
		printf("队头元素 -- 姓名：%s  年龄： %d\n", pFront->name, pFront->age);
		//访问队尾
		struct Person* pBack = BackSeqQueue(myQueue);
		printf("队尾元素 -- 姓名：%s  年龄： %d\n", pBack->name, pBack->age);
		//出队
		PopSeqQueue(myQueue);
	}
 
	printf("队列大小为：%d\n", SizeSeqQueue(myQueue));
 
	//销毁队列
	DestroySeqQueue(myQueue);
	return 0;
}

3.2.4队列的链式存储

基本概念

队列也是一种特殊的线性表；可以用线性表链式存储来模拟队列的链式存储。

1.创建三个文件

2.代码


//1.Queue_ByLinkedList_Head.h 部分
 
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
typedef void* pLinkedQueue;
 
//1.定义节点结构体
struct QueueNode
{
	struct QueueNode* next;
};
 
 
 
//2.定义队列结构体
struct LinkedQueue
{
	struct QueueNode pLinkedQueueHeader;
	struct QueueNode* pLinkedQueueTail;
	int Size;
};
 
 
 
//3.队列初始化函数声明
pLinkedQueue InitLinkedQueue();
 
 
 
//4.入队列函数声明
void PushLinkedQueue(pLinkedQueue queue, void* data);
 
 
 
//5.出队列函数声明
void PopLinkedQueue(pLinkedQueue queue);
 
 
 
//6.返回队列大小函数声明
int SizeLinkedQueue(pLinkedQueue queue);
 
 
 
//7.判断队列是否为空函数声明
int IsEmptyLinkedQueue(pLinkedQueue queue);
 
 
 
//8.返回队头函数声明
void* FrontLinkedQueue(pLinkedQueue queue);
 
 
 
//9.返回队尾函数声明
void* BackLinkedQueue(pLinkedQueue queue);
 
 
 
//10.销毁函数声明
void DestroyLinkedQueue(pLinkedQueue queue);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
//2.Queue_ByLinkedList_Function.c 部分
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include"Queue_ByLinkedList_Head.h"
 
 
 
//3.队列初始化函数实现
pLinkedQueue InitLinkedQueue()
{
	struct LinkedQueue* myQueue = malloc(sizeof(struct LinkedQueue));
	if (myQueue == NULL)
	{
		return NULL;
	}
	myQueue->pLinkedQueueHeader.next = NULL;
	myQueue->pLinkedQueueTail = &myQueue->pLinkedQueueHeader;
	myQueue->Size = 0;
	return myQueue;
}
 
 
 
//4.入队列函数实现
void PushLinkedQueue(pLinkedQueue queue, void* data)
{
	if (queue == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
 
	struct LinkedQueue* myQueue = queue;
	struct QueueNode* myQueueNode = data;
 
	myQueue->pLinkedQueueTail->next = myQueueNode;
	myQueueNode->next = NULL;
 
	//更新新的尾节点
	myQueue->pLinkedQueueTail = myQueueNode;
	myQueue->Size++;
}
 
 
 
//5.出队列函数实现
void PopLinkedQueue(pLinkedQueue queue)
{
	if (queue == NULL)
	{
		return;
	}
	struct LinkedQueue* myQueue = queue;
	if (myQueue->Size == 0)
	{
		return;
	}
 
	//当只有一个节点时情况需要特殊处理
	if (myQueue->Size == 1)
	{
		myQueue->pLinkedQueueHeader.next = NULL;
		myQueue->pLinkedQueueTail = &myQueue->pLinkedQueueHeader;
		myQueue->Size--;
		return;
	}
 
	//更改指针方向
	myQueue->pLinkedQueueHeader.next = myQueue->pLinkedQueueHeader.next->next;
	myQueue->Size--;
}
 
 
 
//6.返回队列大小函数实现
int SizeLinkedQueue(pLinkedQueue queue)
{
	if (queue == NULL)
	{
		return -1;
	}
	struct LinkedQueue* myQueue = queue;
	return myQueue->Size;
}
 
 
 
//7.判断队列是否为空函数实现
int IsEmptyLinkedQueue(pLinkedQueue queue)
{
	if (queue == NULL)
	{
		return -1;
	}
	struct LinkedQueue* myQueue = queue;
	if (myQueue->Size == 0)
	{
		return 1;
	}
	return 0;
}
 
 
 
//8.返回队头函数实现
void* FrontLinkedQueue(pLinkedQueue queue)
{
	if (queue == NULL)
	{
		return;
	}
	struct LinkedQueue* myQueue = queue;
	return myQueue->pLinkedQueueHeader.next;
}
 
 
 
//9.返回队尾函数实现
void* BackLinkedQueue(pLinkedQueue queue)
{
	if (queue == NULL)
	{
		return;
	}
	struct LinkedQueue* myQueue = queue;
	return myQueue->pLinkedQueueTail;
}
 
 
 
//10.销毁函数实现
void DestroyLinkedQueue(pLinkedQueue queue)
{
	if (queue == NULL)
	{
		return;
	}
	free(queue);
	queue = NULL;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
//3.Queue_ByLinkedList_Main.c 部分
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include"Queue_ByLinkedList_Head.h"
 
 
//测试
 
//1.定义数据结构体
struct Person
{
	void* node;
	char name[64];
	int age;
};
 
 
 
int main()
{
	//初始化队列
	pLinkedQueue myQueue = InitLinkedQueue();
 
	//准备数据
	struct Person p1 = { NULL,"aaa", 10 };
	struct Person p2 = { NULL,"bbb", 20 };
	struct Person p3 = { NULL,"ccc", 30 };
	struct Person p4 = { NULL,"ddd", 40 };
 
	//入队
	PushLinkedQueue(myQueue, &p1);
	PushLinkedQueue(myQueue, &p2);
	PushLinkedQueue(myQueue, &p3);
	PushLinkedQueue(myQueue, &p4);
	printf("队列大小为：%d\n", SizeLinkedQueue(myQueue));
	while (IsEmptyLinkedQueue(myQueue) == 0)
	{
		//访问队头
		struct Person* pFront = FrontLinkedQueue(myQueue);
		printf("链式存储::队头元素 -- 姓名：%s  年龄： %d\n", pFront->name, pFront->age);
		//访问队尾
		struct Person* pBack = BackLinkedQueue(myQueue);
		printf("链式存储::队尾元素 -- 姓名：%s  年龄： %d\n", pBack->name, pBack->age);
		//出队
		PopLinkedQueue(myQueue);
	}
 
	printf("队列大小为：%d\n", SizeLinkedQueue(myQueue));
 
	//销毁队列
	DestroyLinkedQueue(myQueue);
	return 0;
}

相关阅读:
酷玩Go命令行工具—Cobra
微服务的发展历程的详细说明及每个阶段主流的架构和组件
 Notion+Zotero+Notero 联动教程（23年9月更新版）
猿创征文丨赶紧进来!!! 详细介绍C语言指针(九千字完结篇)
SingletonKit单例源码阅读学习
 ETH2.0 合并，投资者该做些什么准备？
[unity]三角形顶点顺序
 16-Linux磁盘管理
 电商后台项目 + 源码
 一次企业网丢包故障定位过程
原文地址：https://blog.csdn.net/qq_43205256/article/details/126042073