一步一步学数据结构之1--1（循环队列--线性表实现）

 

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

       如图



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

l 创建队列

l 销毁队列

l 清空队列

l 入队

l 出队

l 返回队首元素

l 返回队的大小

l 返回队的最大长度

代码总分为三个文件：

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

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

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

整体结构图为：



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

 

入队操作：

   如图：

  


出队操作：

  如图：



返回队首元素：

  如图：



OK! 上代码：

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

 

#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） ：

 

#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     ：

  

#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;
}