您的位置：首页 > 理论基础 > 数据结构算法

数据结构队列及其用法（C语言实现）

2015-04-22 20:44 453 查看
一、对列的定义

队列是一种特殊的线性表，它的特殊之处在于它只允许在表的前端进行删除操作，在表的后端进行插入操作，

像栈一样，队列也是一种操作受限的线性表。进行插入操作端称为队尾，进行删除操作端称为队首。在一个队列中插入一个队列元素称为入队，在队列中产出一个队列元素称为出队。

二、队列的特点

队列只允许在一段插入，在另一端删除，所以只有最早进入对列的才能最先从队列中删除，故队列又称先进先

出，即first in first out，简称FIFO。

对列有顺序队列和循环队列两种。顺序队列是指为其静态分配或者动态申请一段连续的存储空间。并设置两个

指针进行管理，一个是队头指针front，它指向队头元素；另一个是队尾指针rear，它指向下一个入队元素的存储位置，它的存储及操作结构如下：





循环队列是为了为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，

并称这种向量为循环向量。存储在其中的队列称为循环队列。它的存储及操作结构如下：



三、对列的基本操作

首先我们先来看下链式队列的操作：

#include<iostream>
#include<cstdio>
#include<malloc.h>
using namespace std;
typedef struct NODE
{
int data;
struct NODE *next;
}node;
typedef struct
{
struct NODE *front;
struct NODE *rear;
int size;
}Queue;
Queue *initqueue()      //构造一个空队列
{
Queue *p;
p = (Queue *)malloc(sizeof(Queue));
if(p == NULL)
exit(0);
p->front = NULL;
p->rear = NULL;
p->size = 0;
return p;
}
void destroyqueue(Queue *p)     //销毁队列
{
while(p->front)
{
p->rear = p->front->next;
free(p->front);
p->front = p->rear;
}
}
void clearqueue(Queue *p)       //清空一个队列
{
p->front = p->rear;
p->front->next = NULL;
p->size = 0;
}
int emptyqueue(Queue *p)       //判断队列是否为空
{
if(p->front == NULL && p->rear == NULL)
return 1;
return 0;
}
int getlength(Queue *p)           //返回对列的长度
{
return p->size;
}
int getfront(Queue *p)            //返回队首元素
{
int a;
if(p->front->next == NULL)
return 0;
a = p->front->data;
return a;
}
void pushqueue(Queue *p, int data)          // 将一个新元素入队
{
node *que = (node *)malloc(sizeof(node));
que->data = data;
que->next = NULL;
if(emptyqueue(p))
p->front = p->rear = que;
else
{
p->rear->next = que;
p->rear = que;
}
p->size++;
}
void popqueue(Queue *p)          // 将队首元素出队
{
if(p->front->next == NULL)
return;
node *que;
que = p->front;
p->front = que->next;
if(p->rear == que)
p->rear = NULL;
p->size--;
free(que);
}
int main()
{
Queue *p;
p = initqueue();
for(int i=0;i<10;i++)
pushqueue(p, i);
int n = getlength(p);
printf("%d\n", n);
clearqueue(p);
for(int i=0;i<10;i++)
{
int a = getfront(p);
printf("%d  ", a);
popqueue(p);
}
printf("\n");
int n1 = getlength(p);
printf("%d\n", n1);
destroyqueue(p);

return 0;
}
我们在无法估计队列长度时就要用到上述的链式队列。

但是如果我们队列长度的最大值是确定的，那么我们可以使用下面的循环队列：

#include<stdio.h>
#include<malloc.h>
#define MAXSIZE 20  //队列的最大长度
typedef struct
{
int data[MAXSIZE]; //队列
int front; //队头的游标
int rear;  //队尾的游标
} Queue;
void InitQueue(Queue *q) //初始化队列
{
q->front = q->rear = 0;
}
void EnQueue(Queue *q,int e) //让元素e进队
{
if((q->rear + 1) % MAXSIZE == q->front) //队列已满
return;
q->data[q->rear] = e; //元素e进队
q->rear = (q->rear + 1) % MAXSIZE; //游标rear上前进一位,如果已达最后,就移到前面
}
void DeQueue(Queue *q,int *e) //队头的元素出队存入*e
{
if(q->rear == q->front) //如果队列为空返回
return;
*e = q->data[q->front]; //返回队头的元素
q->front = (q->front + 1) % MAXSIZE; //游标front向前移一位,如果是队列的末尾移动到最前面
}
int IsEmpty(Queue *q) //判断队列是否为空
{
if(q->front == q->rear)
return 1;
return 0;
}
int GetQueueLength(Queue *q) //返回队列的长度
{
return (q->rear - q->front + MAXSIZE) % MAXSIZE;
}
void Clear(Queue *q) //清空队列
{
q->front = q->rear = 0;
}
void Print(Queue *q) //打印队列
{
if(q->front == q->rear)
return;
else if(q->rear < q->front)
{
for(int i = q->front; i < MAXSIZE; ++i)
printf("%d ",q->data[i]);
for(int i = 0; i < q->rear; ++i)
printf("%d ",q->data[i]);
printf("\n");
}
else
{
for(int i = q->front; i < q->rear; ++i)
printf("%d ",q->data[i]);
printf("\n");
}
}
int main()
{
Queue q;
InitQueue(&q);
for(int i = 1; i < 20; ++i)
EnQueue(&q,i);
Print(&q);
int k;
DeQueue(&q,&k);
EnQueue(&q,30);
Print(&q);
return 0;
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航