本文深入探讨了队列这一特殊线性表的概念，包括其基本原理、操作方式及在操作系统和客服系统中的应用。详细讲解了队列的顺序存储和链式存储设计，并提供了具体实现代码，帮助读者理解队列在程序设计中的重要作用。
目录：
队列基本概念：常用操作
队列的顺序存储设计与实现
1）基本概念 2）设计与实现
队列的链式存储设计与实现
1）基本概念 2）设计与实现
总结回顾
1.队列基本概念
队列是一种特殊的线性表
队列仅在线性表的两端进行操作
队头(Front):取出数据元素的一端
队尾(Rear):插入数据元素的一端
队列不允许在中间部位进行操作！
操作系统和客服系统中，都是应用了一种数据结构来实现刚才提到的先进先出的排队功能，这就是队列。
队列(queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
队列是一种先进先出(First In First Out)的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。假设队列是q=(a1,a2,a3,......,an),那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，列在最后。这也比较符合我们通常生活中的习惯，排在第一个的优先队列，最后来的当然排在队伍最后，如图所示。
队列在程序设计中用得非常频繁。前面我们已经举了两个例子，再比如用键盘进行各种字母或数字的输入，到显示器上如记事本软件上的输出，其实就是队列的典型
常用操作：销毁队列；清空队列；进队列；出队列；获取队头元素；获取队列的长度
#ifndef _MY_QUEUE_H_
#define _MY_QUEUE_H_
typedef void Queue;
Queue* Queue_Create();
void Queue_Destroy(Queue* queue);
void Queue_Clear(Queue* queue);
int Queue_Append(Queue* queue,void* item);
void* Queue_Retrieve(Queue* queue);
void* Queue_Header(Queue* queue);
int Queue_Length(Queue* queue);
#endif//_MY_QUEUE_H_
2.队列的顺序存储设计与实现
#ifndef _MY_SEQQUEUE_H_
#define _MY_SEQQUEUE_H_
typedef void SeqQueue;
SeqQueue* SeqQueue_Create(int capacity);
void SeqQueue_Destroy(SeqQueue* queue);
void SeqQueue_Clear(SeqQueue* queue);
int SeqQueue_Append(SeqQueue* queue, void* item);
void* SeqQueue_Retrieve(SeqQueue* queue);
void* SeqQueue_Header(SeqQueue* queue);
int SeqQueue_Length(SeqQueue* queue);
int SeqQueue_Capacity(SeqQueue* queue);
#endif//_MY_SEQQUEUE_H_
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include"seqqueue.h"
#include"seqlist.h"
//队列也是一种特殊的线性表
//创建一个队列相当于创建一个顺序存储线性表
SeqQueue* SeqQueue_Create(int capacity)
{
return SeqList_Create(capacity);
}
//销毁队列相当于销毁一个线性表
void SeqQueue_Destroy(SeqQueue* queue)
{
return SeqList_Destroy(capacity);
}
//清空队列相当于清空线性表
void SeqQueue_Clear(SeqQueue* queue)
{
SeqList_Clear(queue);
}
//向队列添加一个元素相当于向线性表中添加一个元素
int SeqQueue_Append(SeqQueue* queue, void* item)
{
return SeqList_Insert(queue, item, SeqList_Length(queue));
}
//出队列相当于从线性表中删除0号位置元素
void* SeqQueue_Retrieve(SeqQueue* queue)
{
return SeqList_Delete(queue, 0);
}
void* SeqQueue_Header(SeqQueue* queue)
{
return SeqList_Get(queue, 0);
}
int SeqQueue_Length(SeqQueue* queue)
{
return SeqList_Length(queue);
}
int SeqQueue_Capacity(SeqQueue* queue)
{
return SeqList_Capacity(queue);
}
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include"seqqueue.h"
void main()
{
int i = 0;
int a[10];
SeqQueue* queue = NULL;
queue=SeqQueue_Create(10);
if (queue == NULL)
{
return;
}
//入队列
for (i = 0; i < 5; i++)
{
a[i] = i + 1;
SeqQueue_Append(queue, &a[i]);
}
//打印队列的属性
printf("len:%d\n", SeqQueue_Length(queue));
printf("header:%d\n", *((int*)SeqQueue_Header(queue)));
printf("capacity:%d\n", SeqQueue_Capacity(queue));
while (SeqQueue_Length(queue)>0)
{
int tmp = *((int*)SeqQueue_Retrieve(queue));
printf("tmp:%d", tmp);
}
SeqQueue_Destroy(queue);
/*
SeqQueue* SeqQueue_Create(int capacity);
void SeqQueue_Destroy(SeqQueue* queue);
void SeqQueue_Clear(SeqQueue* queue);
int SeqQueue_Append(SeqQueue* queue, void* item);
void* SeqQueue_Retrieve(SeqQueue* queue);
void* SeqQueue_Header(SeqQueue* queue);
int SeqQueue_Length(SeqQueue* queue);
int SeqQueue_Capacity(SeqQueue* queue);
*/
return;
}
3.队列的链式存储设计与实现
队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们将它简称为链队列。为了操作上的方便，我们将队头指针指向链队列的头结点，而队尾指针指向终端结点，如图所示：
空队列时，front和rear都指向头结点，如图所示：
#ifndef _MY_LINKQUEUE_H_
#define _MY_LINKQUEUE_H_
typedef void LinkQueue;
LinkQueue* LinkQueue_Create();
void LinkQueue_Destroy(LinkQueue* queue);
void LinkQueue_Clear(LinkQueue* queue);
int LinkQueue_Append(LinkQueue* queue, void* item);
void* LinkQueue_Retrieve(LinkQueue* queue);
void* LinkQueue_Header(LinkQueue* queue);
int LinkQueue_Length(LinkQueue* queue);
#endif//_MY_LINKQUEUE_H_
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include"linkqueue.h"
#include"linklist.h"
//队列也是一种特殊的线性表
//队列的业务节点的数据结构
typedef struct _tag_LinkQueueNode
{
LinkListNode node;
void* item;
}TLinkQueueNode;
//创建队列相当于创建线性表
LinkQueue* LinkQueue_Create()
{
return LinkList_Create();
}
//销毁队列相当于销毁线性表
//结点的内存管理
void LinkQueue_Destroy(LinkQueue* queue)
{
LinkQueue_Clear(queue);
LinkList_Destroy(queue);
}
//如果清空队列需要显示的把队列中的所有节点搞出来
//释放每一个结点
void LinkQueue_Clear(LinkQueue* queue)
{
while (LinkQueue_Length(queue) > 0)
{
LinkQueue_Retrieve(queue);
}
LinkList_Clear(queue);
}
//向队列中添加元素，相当于向线性表的尾部添加元素
int LinkQueue_Append(LinkQueue* queue, void* item)
{
int ret = 0;
TLinkQueueNode* tmp = NULL;
tmp = (TLinkQueueNode*)malloc(sizeof(TLinkQueueNode));
if (tmp == NULL)
{
ret = -1;
printf("func LinkQueue_Append() malloc err:%d",ret);
return ret;
}
meset(tmp, 0, sizeof(TLinkQueueNode)); //做一个负责
//tmp->node.next=NULL;
tmp->item = item;
//需要把栈的item（栈的业务节点）转化成链表的LinkListNode
LinkList_Insert(queue, (LinkListNode*)tmp, LinkList_Length(queue));
if (ret != 0)
{
printf("func LinkList_Insert() err:%d\n", ret);
if (tmp != NULL) free(tmp);
return ret;
}
return 0;
}
//从队列中删除元素相当于从线性表的头部删除元素
void* LinkQueue_Retrieve(LinkQueue* queue)
{
TLinkQueueNode *tmp = NULL;
void *ret = NULL;
tmp = (TLinkQueueNode*)LinkList_Delete(queue, 0);
if (tmp == NULL)
{
printf("func LinkList_Delete() err\n");
return NULL;
}
//删除之前缓存
ret = tmp->item;
if (tmp != NULL)
{
free(tmp);
}
return ret;
}
//获取队列头部元素相当于从线性表的0号位置拿数据
void* LinkQueue_Header(LinkQueue* queue)
{
TLinkQueueNode *tmp = NULL;
void *ret = NULL;
tmp = (TLinkQueueNode *)LinkList_Get(queue, 0);
if (tmp == NULL)
{
printf("func LinkList_Get() err\n");
return NULL;
}
return tmp->item;
}
//求队列的长度相当于求线性表的长度
int LinkQueue_Length(LinkQueue* queue)
{
return LinkList_Length(queue);
}
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include"linkqueue.h"
void main()
{
int i, a[10];
LinkQueue *queue = NULL;
queue = LinkQueue_Create();
if (queue == NULL)
{
return;
}
//向队列中添加元素
for (i = 0; i < 5; i++)
{
a[i] = i + 1;
LinkQueue_Append(queue, &a[i]);
}
//求队列的属性
printf("len:%d\n", LinkQueue_Length(queue));
printf("header:%d\n", *((int*)LinkQueue_Header(queue)));
//出队列
while (LinkQueue_Length(queue) > 0)
{
int tmp;
tmp = *((int*)LinkQueue_Retrieve(queue));
printf("tmp:%d\n", tmp);
}
//销毁队列
LinkQueue_Destroy(queue);
/*
void LinkQueue_Destroy(LinkQueue* queue);
void LinkQueue_Clear(LinkQueue* queue);
int LinkQueue_Append(LinkQueue* queue, void* item);
void* LinkQueue_Retrieve(LinkQueue* queue);
void* LinkQueue_Header(LinkQueue* queue);
int LinkQueue_Length(LinkQueue* queue);
*/
return;
}
4.总结回顾
栈(stack)是限定仅在表尾进行插入和删除操作的线性表。
队列(queue)是指只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
他们均可以用线性表的顺序存储结构来实现，但都存在这顺序村相互的一些弊端。
对于栈来说，如果是两个相同数据类型的栈，则可以用数组的两端做栈底的方法来让两个栈共享数据，这就可以最大化地利用数组的空间。
对于队列来说，为了避免数组插入和删除时需要移动数据，于是就引入了循环队列，使得队头和队尾可以在数组中循环变化。解决了移动数据的时间损耗，使得本来插入和删除是O(n)的时间复杂度变成了O(1)。
它们也都可以通过链式存储结构来实现，实现原则上与线性表基本相同。
扫一扫
2203
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
