DS线性表之栈和队列

前言

我们前面已经介绍并实现了顺序表和链表以及介绍了他们的优缺点!本期我们再来学习一个基本数据结构栈和队列~!这里的栈可不是内存的那个栈,内存的那个栈是操作系统的概念,而这个栈是数据结构的栈,是一个容器。他们是两个不同学科的概念不要混淆了!!!

本期内容介绍

栈的概念和分类

顺序栈的实现

链式栈的实现

队列的概念和分类

链式队列的实现

循环队列的实现

目录

前言

本期内容介绍

一、栈的概念和分类

二、顺序栈的实现

栈的申明

初始化

销毁

入栈

出栈

获取栈顶元素

获取栈的有效元素个数

判断是否为空

三、链式栈的实现

链式栈的申明

创建一个新节点

销毁

入栈

出栈

获取栈顶元素

判断栈是否为空

获取栈的有效元素个数

全部源码:

四、队列的概念和分类

五、链式队列的实现

队列的申明

初始化

销毁

开一个新节点

入队列

出队列

获取队头元素

获取队尾数据

判断是否为空

获取队列元素个数

全部源码:

六、循环队列的实现

循环队列的申明

初始化

销毁

判断是否为空

判断是否已满

入队列

删除

获取元素的个数

获取队头数据

获取队尾的数据


一、栈的概念和分类

栈(stack):是一种特殊的线性表。只允许在固定的一端进行插入和删除操作的数据结构。进行插入和删除操作的那一端被称作栈顶,另一端被称作栈底!栈的特点是后进先出(LIFO),即后入栈的数据先出来!根据实现方式可以分为顺序栈和链式栈~!

压栈(入栈):栈的插入操作叫做压栈/入栈/进栈。

出栈:栈的删除操作叫做出栈。

入栈和出栈都在栈顶!

什么意思呢?你可能没有太明白,我来画张图理解一下:

DS线性表之栈和队列_第1张图片

二、顺序栈的实现

栈的实现可以用数组也可以使用链表,我们先来用数组来实现,也就是顺序栈!顺序栈又可分为静态和动态的,我们前面顺序表以及通讯录介绍了静态的版本几乎没用,很不实用。所以这里我们还是采用动态版本!非要静态版的话,就在他满的时候不要插了(入栈)!!!

静态版本栈的定义:

//栈的静态定义
typedef int STDataType;
#define N 100
struct Stack
{
	STDataType a[N];
	int top;//栈顶
};

栈的申明

//栈的都动态定义
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;//栈顶
	int capacity;//容量
}ST;

初始化

//初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

销毁

//销毁
void STDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	STInit(ps);
}

入栈

//入栈
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	//判断扩容
	if (ps->capacity == ps->top)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("malloc failed");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newcapacity;
	}

	//插入
	ps->a[ps->top++] = x;
}

出栈

//出栈
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);//空
	ps->top--;
}

获取栈顶元素

//获取栈顶元素
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);//空
	return ps->a[ps->top - 1];
}

获取栈的有效元素个数

//获取栈的有效元素个数
int STSize(ST* ps)
{
	return ps->top;
}

判断是否为空

//是否为空
bool IsEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

OK,这块前面已经写过多次了,就不在多赘述了~!下面我们来测试一把:

#include "Stack.h"

void Test()
{
	ST s;
	STInit(&s);
	for (int i = 9; i > 0; i--)
	{
		STPush(&s, i);
	}

	while (!IsEmpty(&s))
	{
		printf("%d ", STTop(&s));
		STPop(&s);
	}

	STDestory(&s);
}

int main()
{
	Test();
	return 0;
}

DS线性表之栈和队列_第2张图片

是不是符合后进先出啊!下面我们在来实现链式栈!

三、链式栈的实现

栈的另一种实现方式就是用单链表,当然带不带头都可以!我们这里选择不带头的,如果不带头的能搞定带头的那就是小卡拉米~!由于栈的特点(后进先出),再结合单链表的特点头插头删效率很高,所以我们采用单链表的头来当栈顶,单链表的尾为栈底。

链式栈的申明

typedef STDataType;
typedef struct Stack
{
	STDataType data;
	struct Stack* next;
}ST;

创建一个新节点

其实这里和单链表那里一样可以不初始化的。我们直接进行其他操作!

//创建一个新节点
ST* BuyNode(STDataType x)
{
	ST* newnode = (ST*)malloc(sizeof(ST));
	if (newnode == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

销毁


//销毁栈
void STDestory(ST** head)
{
	assert(head);
	ST* cur = *head, * tail = NULL;
	while (cur)
	{
		tail = cur->next;
		free(cur);
		cur = tail;
	}

	*head = NULL;
}

入栈

//插入
void Push(ST** head, STDataType x)
{
	assert(head);

	ST* node = BuyNode(x);
	node->next = *head;
	*head = node;
}

出栈

//出栈
void Pop(ST** head)
{
	assert(head);
	assert(*head);//栈为空的情况

	ST* del = *head;
	*head = (*head)->next;
	free(del);
}

获取栈顶元素

//获取栈顶的元素
STDataType STTop(ST* head)
{
	assert(head);
	return head->data;
}

判断栈是否为空

//是否为空
bool STEmpty(ST* head)
{
	return head == NULL;
}

获取栈的有效元素个数

//获取栈的有效元素个数
int STSize(ST* head)
{
	int size = 0;
	while (head)
	{
		++size;
		head = head->next;
	}

	return size;
}

OK测试一下:

#include "Stack.h"

void Test()
{
	ST* s = NULL;
	Push(&s, 1);
	Push(&s, 2);
	Push(&s, 3);
	printf("size = %d\n", STSize(s));

	while (!STEmpty(s))
	{
		printf("%d ", STTop(s));
		Pop(&s);
	}

	printf("\nsize = %d ", STSize(s));

	STDestory(&s);
}

int main()
{
	Test();
	return 0;
}

DS线性表之栈和队列_第3张图片

OK,是不是实现了~!其实这里就是新瓶装旧酒~!下面我们来一起看看另一个数据结构队列~!

全部源码:

#include 
#include 
#include 
#include 

typedef STDataType;
typedef struct Stack
{
	STDataType data;
	struct Stack* next;
}ST;


//创建一个新节点
ST* BuyNode(STDataType x);

//销毁栈
void STDestory(ST** head);

//入栈
void Push(ST** head, STDataType x);

//出栈
void Pop(ST** head);

//获取栈顶的元素
STDataType STTop(ST* head);

//是否为空
bool STEmpty(ST* head);

//获取栈的有效元素个数
int STSize(ST* head);
#include "Stack.h"

//创建一个新节点
ST* BuyNode(STDataType x)
{
	ST* newnode = (ST*)malloc(sizeof(ST));
	if (newnode == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//销毁栈
void STDestory(ST** head)
{
	assert(head);
	ST* cur = *head, * tail = NULL;
	while (cur)
	{
		tail = cur->next;
		free(cur);
		cur = tail;
	}

	*head = NULL;
}

//入栈
void Push(ST** head, STDataType x)
{
	assert(head);

	ST* node = BuyNode(x);
	node->next = *head;
	*head = node;
}

//出栈
void Pop(ST** head)
{
	assert(head);
	assert(*head);//栈为空的情况

	ST* del = *head;
	*head = (*head)->next;
	free(del);
}

//获取栈顶的元素
STDataType STTop(ST* head)
{
	assert(head);
	return head->data;
}

//是否为空
bool STEmpty(ST* head)
{
	return head == NULL;
}

//获取栈的有效元素个数
int STSize(ST* head)
{
	int size = 0;
	while (head)
	{
		++size;
		head = head->next;
	}

	return size;
}
#include "Stack.h"

void Test()
{
	ST* s = NULL;
	Push(&s, 1);
	Push(&s, 2);
	Push(&s, 3);
	printf("size = %d\n", STSize(s));

	while (!STEmpty(s))
	{
		printf("%d ", STTop(s));
		Pop(&s);
	}

	printf("\nsize = %d ", STSize(s));

	STDestory(&s);
}

int main()
{
	Test();
	return 0;
}

四、队列的概念和分类

队列(Queue)也是一种特殊的线性表,他只允许在固定的一段进行插入(入队列),另一端进行删除(出队列)。插入的那一端叫做队尾,删除的那一端叫做队头~!队列的特点是先进先出(和你排队买饭的一样,先来的先买)! 队列的实现也分为数组和链式,当然数组的删除效率不高所以一般采用链式队列,但数组队列有一个很好的结构 ---- 循环队列,我们也会来实现的!

OK,还是来画个队列的图 ,大概先来认识一下:

DS线性表之栈和队列_第4张图片

这就是队列操作的一个过程~!我们下面来实现一下~!

五、链式队列的实现

上面也谈到了用数组实现的话删除(出队列)效率低,所以我们这里采用链表实现,用哪种链表实现呢?其实这里最好的是单链表(带不带头都行),你可能说要找尾进行入队列,所以双向循环较好,但我想说的是单链表给一个尾指针不也能很好的解决这个问题吗?所以这里做最好的解决方案是用单链表+一个尾指针实现~!

队列的申明

typedef int QDataType;
typedef struct QListNode
{
	QDataType data;
	struct QListNode* next;
}QNode;

由于考虑到插入删除的时候得传二级指针,相对稍微麻烦一点,所以这里既要控制队头也要记录队尾,我们不妨在来一个结构体,里面成员是队头指针和队尾指针,这样做的好处就是不用传二级指针了,要改变队头指针的值只需要传结构体的指针即可~!为了获取队列中的数据我们这里还可以加一个size  !

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

初始化

//初始化
void QInit(Queue* p)
{
	assert(p);
	p->head = p->tail = NULL;
	p->size = 0;
}

销毁

//销毁
void QDestory(Queue* p)
{
	assert(p);
	QNode* cur = p->head, *next = NULL;
	while (cur)
	{
		next = cur->next;
		free(cur);
		cur = next;
	}
	p->head = p->tail = NULL;
	p->size = 0;
}

开一个新节点

//开一个新节点
QNode* BuyNode(QDataType x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

入队列

//入队列
void QPush(Queue* p, QDataType x)
{
	assert(p);
	QNode* node = BuyNode(x);
	if (p->head == NULL)
	{
		p->head = p->tail = node;
	}
	else
	{
		p->tail->next = node;
		p->tail = node;
	}
	p->size++;
}

出队列

//出队列
void QPop(Queue* p)
{
	assert(p);
	assert(p->head);

	QNode* next = p->head->next;
	free(p->head);
	p->head = next;
	p->size--;
}

获取队头元素

//获取队列头的数据
QDataType QTop(Queue* p)
{
	assert(p);
	assert(p->size > 0);

	return p->head->data;
}

获取队尾数据

//获取队列尾的数据
QDataType QTail(Queue* p)
{
	assert(p);
	assert(p->size > 0);

	return p->tail->data;
}

判断是否为空

//是否为空
bool QEmpty(Queue* p)
{
	assert(p);
	return p->size == 0;
}

获取队列元素个数

//获取队列的元素个数
int QSize(Queue* p)
{
	assert(p);
	return p->size;
}

OK,测试一把:

DS线性表之栈和队列_第5张图片

OK,实现了先进先出的特点!

全部源码:

#pragma once
#include 
#include 
#include 
#include 

typedef int QDataType;
typedef struct QListNode
{
	QDataType data;
	struct QListNode* next;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

//初始化
void QInit(Queue* p);

//销毁
void QDestory(Queue* p);

//开一个新节点
QNode* BuyNode(QDataType x);

//入队列
void QPush(Queue* p, QDataType x);

//出队列
void QPop(Queue* p);

//获取队列头的数据
QDataType QTop(Queue* p);

//获取队列尾的数据
QDataType QTail(Queue* p);

//是否为空
bool QEmpty(Queue* p);

//获取队列的元素个数
int QSize(Queue* p);
#include "Queue.h"

//初始化
void QInit(Queue* p)
{
	assert(p);
	p->head = p->tail = NULL;
	p->size = 0;
}

//销毁
void QDestory(Queue* p)
{
	assert(p);
	QNode* cur = p->head, *next = NULL;
	while (cur)
	{
		next = cur->next;
		free(cur);
		cur = next;
	}
	p->head = p->tail = NULL;
	p->size = 0;
}

//开一个新节点
QNode* BuyNode(QDataType x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

//入队列
void QPush(Queue* p, QDataType x)
{
	assert(p);
	QNode* node = BuyNode(x);
	if (p->head == NULL)
	{
		p->head = p->tail = node;
	}
	else
	{
		p->tail->next = node;
		p->tail = node;
	}
	p->size++;
}

//出队列
void QPop(Queue* p)
{
	assert(p);
	assert(p->head);

	QNode* next = p->head->next;
	free(p->head);
	p->head = next;
	p->size--;
}

//获取队列头的数据
QDataType QTop(Queue* p)
{
	assert(p);
	assert(p->size > 0);

	return p->head->data;
}

//获取队列尾的数据
QDataType QTail(Queue* p)
{
	assert(p);
	assert(p->size > 0);

	return p->tail->data;
}

//是否为空
bool QEmpty(Queue* p)
{
	assert(p);
	return p->size == 0;
}

//获取队列的元素个数
int QSize(Queue* p)
{
	assert(p);
	return p->size;
}
void TestQueue()
{
	Queue q;
	QInit(&q);

	QPush(&q, 1);
	QPush(&q, 2);
	QPush(&q, 3);
	QPush(&q, 4);
	QPush(&q, 5);
	printf("size = %d\n", QSize(&q));

	while (!QEmpty(&q))
	{
		printf("%d ", QTop(&q));
		QPop(&q);
	}
	printf("\nsize = %d\n", QSize(&q));

	QDestory(&q);

}

int main()
{
	TestQueue();
	return 0;
}

六、循环队列的实现

循环队列也是很常见也很常用的一种队列,例如操作系统中有个模型叫“生产者和消费者”就用的是循环队列,当然他也可以用数组实现也可以用循环链表来实现!上面的使用链表实现的,我们这里用数组来实现~!

OK,开始之前还是来先画一个循环队列看看~!

DS线性表之栈和队列_第6张图片

他这个是怎么玩的呢?他是把空间开好后用两个指针(front和rear(指向当前位置的下一个位置)下标)来控制的,插入就是覆盖rear指向的那个位置,然后rear向后移动1,不用挪动数据。删除也是一样让front++一下!这里你可能会问如何判空呢?当front == rear == 0?那啥时候判满呢?是不是不好弄啊!设计这种队列的人想到了一个办法是:多开一个空间把那个空间浪费掉,当rear == front时表示空,当rear + 1 == front时表示满,如果是数组实现的话你要让rear已经是最后一个的话你在加一是不是越界了!所以rear+1 %队列的长度就好了,这样当超过的时候就有回去了(见下图1),删除的时候也是一样要%个队列的长度(见图2)。OK大概就是这样,具体的细节我们实现的时候再解释~!

图1

DS线性表之栈和队列_第7张图片

图2

DS线性表之栈和队列_第8张图片

OK,我们来实现一下:

循环队列的申明

这里的类型申明有两种形式,一种是你直接给好数组的大小,一种是不确定大小得输入!

typedef int LQDataType;
#define MAX 5
typedef struct LQueNode
{
	LQDataType a[MAX];
	int front;//队头
	int rear;//队尾
	int size;//元素个数
}LQ;
typedef int LQDataType;
typedef struct LQueNode
{
	LQDataType* a;
	int front;//队头
	int rear;//队尾
	int k;//队列的大小
	int size;
}LQ;

第二种就是要在初始化的时候进行输入你的队列的大小!其实俩囊中相比较之下,后者更好一点,我就给予第二种来实现~!

初始化

这两种申明不同他们的初始化也不同,静态的只需要控制好front和rear就好,而动态的话不知道你要开多少个所以采用malloc,这个要记得free! 我在这里就演示一下出不同的初始化和销毁~!

静态初始化

//初始化
void LQInit(LQ* p,int k)
{
	assert(p);
	p->front = p->rear = 0;//这里可以是-1,可以是0,我们这里采用后者
	p->size = 0;
}

动态初始化

//初始化
void LQInit(LQ* p, int k)
{
	assert(p);
	p->a = (LQDataType*)malloc(sizeof(LQDataType) * k + 1);
	p->front = p->rear = 0;
	p->k = k;
	p->size = 0;
}

销毁

静态销毁

静态的只考虑把front和rear, size处理好即可,而动态版本的话要先free动态开的数组然后在处理其他的~!

//销毁
void LQDestory(LQ* p)
{
	LQInit(p);
}

动态销毁

//销毁
void LQDestory(LQ* p)
{
	assert(p);
	free(p->a);
	p->front = p->rear = 0;
	p->k = p->size = 0;
}

判断是否为空

我们前面介绍过了,判断为空的条件是front == rear

//是否为空
bool IsEmpty(LQ* p)
{
	assert(p);
	return p->rear == p->front;
}

判断是否已满

前面已经介绍了,为了区分满和空专门多开了一个空间,rear是当前元素的下一个位置,所以当rear+1%实际队列的长度 == front时就是满了~!


//是否为满
bool IsFull(LQ* p)
{
	assert(p);
	return (p->rear + 1) % (p->k + 1) == p->front;
}

入队列

由于这个队列的长度是固定的,所以你在插入即入队列时得先判断是否为满,满了就不要插入了!否则插入到当前rear指向的位置,然后再让rear++,但有可能rear++一下就越界了,所以要对他取队列实际长度的模~!如下图

DS线性表之栈和队列_第9张图片

//插入
void LQPush(LQ* p, LQDataType x)
{
	assert(p);
	if (IsFull(p))
	{
		perror("LQ is full");
		exit(-1);
	}

	p->a[p->rear] = x;
	p->rear++;
	p->rear %= p->k + 1;
	p->size++;
}

删除

还是和前面的插入一样,得先判断是否为空。空了就不要删了!不是空的话就移动front但也要注意一中情况就是本身此时front就在最后,在++一下就越界了,所以得取模或特殊判断一下~!

DS线性表之栈和队列_第10张图片

//删除
void LQPop(LQ* p)
{
	assert(p);
	if (IsEmpty(p))
	{
		perror("LQ is empty");
		exit(-1);
	}

	p->front++;
	p->front %= p->k + 1;
	p->size--;
}

获取元素的个数

这里我定义了一个专门记录的元素size所以直接返回即可,如果没有专门定义size的话也可以用rear-front + 队列的实际长度 %队列的实际长度也可以~!!

//获取元素个数
int LQsize(LQ* p)
{
	assert(p);
	return p->size;
}

获取队头数据

队头的数据相对简单,只要不为空把front的位置的元素返回即可~!

//获取队头的数据
LQDataType LQFront(LQ* p)
{
	assert(p);
	if (IsEmpty(p))
	{
		perror("LQ is empty");
		exit(-1);
	}

	return p->a[p->front];
}

获取队尾的数据

一般情况下,由于rear是当前元素的下一个所以-1直接返回即可,但如果rear此时就在0号下标的位置呢?-1就是负1越界了,所以这里得特殊判断, 当rear == 0时,就返回k的那个位置的元素(队列的实际长度是k+1)。当然还有大佬这样写的(rear + k+ 1) - 1 % (k+1),这种写法就是当你是第一个才有效,其他位置+个(k+1)%(k+1)一样的,简写就是:(rear+k )%(k+1)

//获取队尾的数据
LQDataType LQRear(LQ* p)
{
	assert(p);
	if (IsEmpty(p))
	{
		perror("LQ is empty");
		exit(-1);
	}

	/*if (p->rear == 0)
		return p->a[p->k];
	else
		return p->a[p->rear - 1];*/

	return p->a[(p->rear + p->k) % (p->k + 1)];
}

OK,测试一把:

DS线性表之栈和队列_第11张图片

OK,没有什么问题。除了插入的元素有限以外这个结构还是很优秀的~!是当然可以自己输入的话可以预算一下也是可以用的~!

全部源码:

#define _CRT_SECURE_NO_WARNINGS 1
#include 
#include 
#include 
#include 

typedef int LQDataType;
typedef struct LQueNode
{
	LQDataType* a;
	int front;//队头
	int rear;//队尾
	int k;//队列的大小
	int size;
}LQ;

//初始化
void LQInit(LQ* p, int k);

//销毁
void LQDestory(LQ* p);

//插入
void LQPush(LQ* p, LQDataType x);

//删除
void LQPop(LQ* p);

//是否为空
bool IsEmpty(LQ* p);

//是否为满
bool IsFull(LQ* p);

//获取元素个数
int LQsize(LQ* p);

//获取队头的数据
LQDataType LQFront(LQ* p);

//获取队尾的数据
LQDataType LQRear(LQ* p);




#include "Queue1.h"

初始化
//void LQInit(LQ* p,int k)
//{
//	assert(p);
//	p->front = p->rear = 0;//这里可以是-1,可以是0,我们这里采用后者
//	p->size = 0;
//}

//销毁
//void LQDestory(LQ* p)
//{
//	LQInit(p);
//}

//初始化
void LQInit(LQ* p, int k)
{
	assert(p);
	p->a = (LQDataType*)malloc(sizeof(LQDataType) * k + 1);
	p->front = p->rear = 0;
	p->k = k;
	p->size = 0;
}

//销毁
void LQDestory(LQ* p)
{
	assert(p);
	free(p->a);
	p->front = p->rear = 0;
	p->k = p->size = 0;
}

//是否为空
bool IsEmpty(LQ* p)
{
	assert(p);
	return p->rear == p->front;
}

//是否为满
bool IsFull(LQ* p)
{
	assert(p);
	return (p->rear + 1) % (p->k + 1) == p->front;
}

//插入
void LQPush(LQ* p, LQDataType x)
{
	assert(p);
	if (IsFull(p))
	{
		perror("LQ is full");
		exit(-1);
	}

	p->a[p->rear] = x;
	p->rear++;
	p->rear %= p->k + 1;
	p->size++;
}

//删除
void LQPop(LQ* p)
{
	assert(p);
	if (IsEmpty(p))
	{
		perror("LQ is empty");
		exit(-1);
	}

	p->front++;
	p->front %= p->k + 1;
	p->size--;
}

//获取元素个数
int LQsize(LQ* p)
{
	assert(p);
	return p->size;
}

//获取队头的数据
LQDataType LQFront(LQ* p)
{
	assert(p);
	if (IsEmpty(p))
	{
		perror("LQ is empty");
		exit(-1);
	}

	return p->a[p->front];
}

//获取队尾的数据
LQDataType LQRear(LQ* p)
{
	assert(p);
	if (IsEmpty(p))
	{
		perror("LQ is empty");
		exit(-1);
	}

	/*if (p->rear == 0)
		return p->a[p->k];
	else
		return p->a[p->rear - 1];*/

	return p->a[(p->rear + p->k) % (p->k + 1)];
}
#include "Queue1.h"

void Test2()
{
	LQ q;
	int k = 0, x = 0;
	printf("请输入队列的大小:> ");
	scanf("%d", &k);
	LQInit(&q, k);
	while (k--)
	{
		printf("请输入元素:> ");
		scanf("%d", &x);
		LQPush(&q, x);
	}
	printf("size = %d\n", LQsize(&q));
	printf("队尾:> %d\n", LQRear(&q));

	while(!IsEmpty(&q))
	{
		printf("%d ", LQFront(&q));
		LQPop(&q);
	}

	printf("\nsize = %d\n", LQsize(&q));

	LQDestory(&q);
}

int main()
{
	Test2();
	return 0;
}

OK,本期内容就介绍到这里,好兄弟我们下期再见~!

你可能感兴趣的:(DS初阶,c语言,数据结构,算法)