线性表(List)---队列的顺序存储

队列的顺序存储结构的设计与实现

栈的介绍

定义： 队列是一种特殊的线性表，队列仅在线性表的两端进行操作。

队头(Front)： 取出数据元素的一端。*

队尾(Rear)： 插入数据元素的一端。



队列的常用操作

(1)创建队列

(2)销毁队列

(3)进队列

(4)出队列

(5)获取队列头部元素

(6)获取队列的长度

队列顺序存储结构的设计

队列的顺序存储模型

队列顺序存储结构的实现

因为队列是一种特殊的线性表，所以我们可以重复利用顺序表的顺序存储中的代码，在此基础上实现队列的顺序存储。

- SeqQueue.h

#ifndef _SEQQUEUE_H_
#define _SEQQUEUE_H_

typedef void SeqQueue;
typedef void SeqQueueNode;

//创建队列
SeqQueue *SeqQueue_Create(int capacity);

//销毁队列
void SeqQueue_Destroy(SeqQueue *queue);

//清空队列
void SeqQueue_Clear(SeqQueue *queue);

//进队列
int  SeqQueue_Append(SeqQueue *queue, SeqQueueNode *item);

//出队列
SeqQueueNode *SeqQueue_Retrieve(SeqQueue *queue);

//获取对头元素
SeqQueueNode *SeqQueue_Header(SeqQueue *queue);

//获取队列长度
int SeqQueue_Lenght(SeqQueue *queue);

//获取队列容量
int SeqQueue_Capacity(SeqQueue *queue);

#endif // !_SEQQUEUE_H_

SeqQueue.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "SeqQueue.h"
#include "seqlist.h"

//队列是一中特殊的线性表
//创建队列 相当于创建一个顺序存储的线性表
SeqQueue *SeqQueue_Create(int capacity)
{
return (SeqlistNode *)SeqList_Create(capacity);
}

//销毁队列 相当于销毁一个线性表
void SeqQueue_Destroy(SeqQueue *queue)
{
SeqList_Destroy(queue);
return ;
}

//清空队列 相当于清空线性表
void SeqQueue_Clear(SeqQueue *queue)
{
SeqList_Clear(queue);
return ;
}

//进队列 相当于向线性表末尾添加一个元素
int  SeqQueue_Append(SeqQueue *queue, SeqQueueNode *item)
{
return SeqList_Insert(queue, item, SeqList_Length(queue));
}

//出队列  相当于从线性表中删除0号位置元素
SeqQueueNode *SeqQueue_Retrieve(SeqQueue *queue)
{
return (SeqlistNode *)SeqList_Delete(queue,0);
}

//获取对头元素 相当于获取线性表中0号位置元素
SeqQueueNode *SeqQueue_Header(SeqQueue *queue)
{
return (SeqlistNode *)SeqList_Get(queue, 0);
}

//获取队列长度 相当于获取线性表的长度
int SeqQueue_Lenght(SeqQueue *queue)
{
return SeqList_Length(queue);
}

//获取队列容量 相当于获取线性表的容量
int SeqQueue_Capacity(SeqQueue *queue)
{
return SeqList_Capacity(queue);
}

SeqQueue集成测试框架

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "SeqQueue.h"

void main()
{
int i = 0, ret = 0;
int a[10];
SeqQueue *queue = SeqQueue_Create(10);
if (queue == NULL)
{
printf("func SeqQueue_Create() (queue == NULL) err\n");
return;
}

//入队列
for (; i < 5; i++)
{
a[i] = i + 1;
ret = SeqQueue_Append(queue, (SeqQueueNode *)&a[i]);
if (ret != 0)
{
printf("func SeqQueue_Append() (ret != 0) err:%d\n", ret);
return;
}
}
//打印队列的属性
printf("len:%d\n", SeqQueue_Lenght(queue));
printf("capacity:%d\n", SeqQueue_Capacity(queue));
printf("header:%d\n", *((int *)SeqQueue_Header(queue)));

//出队列
while (SeqQueue_Lenght(queue))
{
int *tmp = (int *)SeqQueue_Retrieve(queue);
if (tmp == NULL)
{
printf("func SeqQueue_Retrieve() (tmp == NULL) err\n");
return;
}
printf("tmp: %d\n", *tmp);
}
SeqQueue_Destroy(queue);

return;
}

结果截图