数据结构（22）循环队列--线性表实现

为充分利用内存空间，克服"假溢出"现象的方法是：将内存空间想象为一个首尾相接的圆环。存储在其中的队列称为循环队列。

如图



这里介绍双向链表的常用操作：

l 创建队列

l 销毁队列

l 清空队列

l 入队

l 出队

l 返回队首元素

l 返回队的大小

l 返回队的最大长度

代码总分为三个文件：

SeqQueue.h ： 放置功能函数的声明，以及表的声明

SeqQueue.c ： 放置功能函数的定义，以及表结点的定义和表的定义

Main.c ： 主函数，使用功能函数完成各种需求，一般用作测试

整体结构图为：



这里详细说下入队操作，出队操作和返回队首元素操作：



入队操作：

如图：




出队操作：

如图：



返回队首元素：

如图：



OK! 上代码：

SeqCircleQueue.h（即上述的SeqQueue.h） ：



[cpp] view
plaincopy

#ifndef _SEQCIRCLEQUEUE_H_

#define _SEQCIRCLEQUEUE_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_Retrueve(SeqQueue* queue);



void* SeqQueue_Header(SeqQueue* queue);



int SeqQueue_Size(SeqQueue* queue);



int SeqQueue_Capacity(SeqQueue* queue);



#endif



SeqCircleQueue.c（即SeqQueue.c） ：



[cpp] view
plaincopy

#include <stdio.h>

#include <malloc.h>

#include "SeqCircleQueue.h"



typedef unsigned int TSeqQueueNode;



typedef struct _tag_SeqQueue

{

int capacity;

int length;

int front;

int rear;

TSeqQueueNode* node;

}TSeqQueue;



SeqQueue* SeqQueue_Create(int capacity)

{

TSeqQueue* ret = NULL;



if(0 <= capacity)

{

ret = (TSeqQueue*)malloc(sizeof(TSeqQueue)+sizeof(TSeqQueueNode)*capacity);

}



if(NULL != ret)

{

ret->capacity = capacity;

ret->length = 0;

ret->front = 0;

ret->rear = 0;

ret->node = (TSeqQueueNode*)(ret+1);

}



return ret;

}



void SeqQueue_Destroy(SeqQueue* queue)

{

free(queue);

}



void SeqQueue_Clear(SeqQueue* queue)

{

TSeqQueue* sQueue = (TSeqQueue*)queue;



if(NULL != sQueue)

{

sQueue->length = 0;

sQueue->front = 0;

sQueue->rear = 0;

}

}



int SeqQueue_Append(SeqQueue* queue, void* item)

{

TSeqQueue* sQueue = (TSeqQueue*)queue;



int ret = (NULL!=sQueue) && (NULL!=item);



ret = ret && (sQueue->length+1 <= sQueue->capacity);



if(ret)

{

sQueue->node[sQueue->rear] = (TSeqQueueNode*)item;



sQueue->rear = (sQueue->rear+1) % sQueue->capacity;



sQueue->length++;

}



return ret;

}



void* SeqQueue_Retrueve(SeqQueue* queue)

{

TSeqQueue* sQueue = (TSeqQueue*)queue;



void* ret = SeqQueue_Header(queue);



if(NULL != ret)

{

sQueue->front = (sQueue->front+1) % sQueue->capacity;



sQueue->length--;

}



return ret;

}



void* SeqQueue_Header(SeqQueue* queue)

{

TSeqQueue* sQueue = (TSeqQueue*)queue;



void* ret = NULL;



if((NULL != sQueue)&&(0 < sQueue->length))

{

ret = (void*)(sQueue->node[sQueue->front]);

}



return ret;

}



int SeqQueue_Size(SeqQueue* queue)

{

TSeqQueue* sQueue = (TSeqQueue*)queue;



int ret = -1;



if(NULL != sQueue)

{

ret = sQueue->length;

}



return ret;

}



int SeqQueue_Capacity(SeqQueue* queue)

{

TSeqQueue* sQueue = (TSeqQueue*)queue;



int ret = -1;



if(NULL != sQueue)

{

ret = sQueue->capacity;

}



return ret;

}



Main.c ：



[cpp] view
plaincopy

#include <stdio.h>

#include "SeqCircleQueue.h"



int main(void)

{

SeqQueue* queue = SeqQueue_Create(6);



int a[10] = {0};

int i = 0;



for(i=0; i<10; i++)

{

a[i] = i+1;



SeqQueue_Append(queue, a+i);

}



printf("Header: %d\n", *(int*)SeqQueue_Header(queue));

printf("Length: %d\n", SeqQueue_Size(queue));

printf("Capacity: %d\n\n", SeqQueue_Capacity(queue));



while(SeqQueue_Size(queue) > 0)

{

printf("Retrieve: %d\n", *(int*)SeqQueue_Retrueve(queue));

}

printf("\n");



for(i=0; i<10; i++)

{

a[i] = i+1;



SeqQueue_Append(queue, a+i);



printf("Retrieve: %d\n", *(int*)SeqQueue_Retrueve(queue));

}



SeqQueue_Destroy(queue);



return 0;

}