数据结构---队列的顺序实现的优化实现

#include <stdio.h>
#include <stdlib.h>
#include "SeqQueue.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[]) 
{
	SeqQueue* queue=SeqQueue_Create(20);
	int a[10];
	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_Length(queue));
	printf("Capacity:%d\n",SeqQueue_Capacity(queue));
	while(SeqQueue_Length(queue)>0)
	{
		printf("Retrieve:%d\n",*(int*)SeqQueue_Retrieve(queue));
	}
	printf("\n");
	for(i=0;i<10;i++)
	{
		a[i]=i+1;
		SeqQueue_Append(queue,a+i);
		printf("Retrieve:%d\n",*(int*)SeqQueue_Retrieve(queue));
	}
	SeqQueue_Destroy(queue);
	return 0;
}

#include "SeqQueue.h"
#include <malloc.h>
#include <stdio.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(capacity>=0)
	{
		ret=(TSeqQueue*)malloc(sizeof(TSeqQueue)+sizeof(TSeqQueueNode)*capacity);
	}
	if(ret!=NULL)
	{
		ret->length=0;
		ret->capacity=capacity;
		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(sQueue!=NULL)
	{
		sQueue->front=0;
		sQueue->rear=0;
		sQueue->length=0;
		
	}
}
int SeqQueue_Append(SeqQueue* queue,void* item)
{
	TSeqQueue* sQueue=(TSeqQueue*)queue;
	int ret=((sQueue!=NULL)&&(item!=NULL));
	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;
}

//原来用顺序表实现，删除元素的时间复杂度为O(n)
//现在为O(1) 
void* SeqQueue_Retrieve(SeqQueue* queue)
{
	TSeqQueue* sQueue=(TSeqQueue*)queue;
	void* ret=SeqQueue_Header(queue);
	if(ret!=NULL)
	{
		sQueue->front=(sQueue->front+1)%sQueue->capacity;
		sQueue->length--;
	}
	return ret;
}
void* SeqQueue_Header(SeqQueue* queue)
{
	TSeqQueue*sQueue=(TSeqQueue*)queue;
	void* ret=NULL;
	if((sQueue!=NULL)&&(sQueue->length>0))
	{
		ret=(void*)(sQueue->node[sQueue->front]);
	}
	return ret;
}
int SeqQueue_Length(SeqQueue* queue)
{
	TSeqQueue*sQueue=(TSeqQueue*)queue;
	int ret=-1;
	if(sQueue!=NULL)
	{
		ret=sQueue->length;
	}
	return ret;
}
int SeqQueue_Capacity(SeqQueue* queue)
{
		TSeqQueue*sQueue=(TSeqQueue*)queue;
	int ret=-1;
	if(sQueue!=NULL)
	{
		ret=sQueue->capacity;
	}
	return ret;
}

#ifndef _SEQQUEUE_H
#define _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