一步一步学数据结构之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;
}