队列的顺序存储设计与实现

//seqlist.h
#ifndef _SEQLIST_H_
#define _SEQLIST_H_

typedef void SeqList;
typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);

void SeqList_Clear(SeqList *list);
void SeqList_Destroy(SeqList *list);

int SeqList_Length(SeqList *list);
int SeqList_Capacity(SeqList *list);
int SeqList_Insert(SeqList *list, SeqListNode *node, int pos);

SeqListNode* SeqList_Delete(SeqList *list,int pos);
SeqListNode* SeqList_Get(SeqList *list, int pos);


#endif

//seqqueue.h
#ifndef _SEQQUEUE_H_
#define _SEQQUEUE_H_
#include"seqlist.h"
typedef void SeqQueue;

SeqQueue *SeqQueue_Create(int capacity);

void SeqQueue_Destroy(SeqQueue *queue);
void SeqQueue_Clear(SeqQueue *queue);

int SeqQueue_Length(SeqQueue *queue);
int SeqQueue_Capacity(SeqQueue *queue);
int SeqQueue_Append(SeqQueue *queue, SeqQueue *item);

void *SeqQueue_Retrieve(SeqQueue *queue);
void *SeqQueue_Header(SeqQueue *queue);

#endif

//seqlist.cpp
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "seqqueue.h"


typedef struct _tag_SeqList
{
	int length;
	int capacity;
	unsigned int *node;
}TSeqList;

SeqList *SeqList_Create(int capacity)
{
	TSeqList *ret = NULL;
	if (capacity < 0)
	{
		printf("SeqList_Create err:capacity < 0\n");
		return NULL;
	}
	ret = (TSeqList *)malloc(sizeof(TSeqList) + sizeof(unsigned int)*capacity);
	if (ret == NULL)
	{
		printf("SeqList_Create err:malloc err\n");
		return NULL;
	}
	memset(ret, 0, sizeof(TSeqList) + sizeof(unsigned int)*capacity);
	ret->node = (unsigned int *)(ret + 1);
	ret->capacity = capacity;
	ret->length = 0;
	return ret;
}

void SeqList_Clear(SeqList *list)
{
	TSeqList *tlist = NULL;
	if (list == NULL)
	{
		printf("SeqList_Clear err\n");
		return;
	}
	tlist = (TSeqList*)list;
	tlist->length = 0;
}

void SeqList_Destroy(SeqList *list)
{
	if (list == NULL)
	{
		printf("SeqList_Destroy err\n");
		return;
	}
	free(list);
}

int SeqList_Length(SeqList *list)
{
	TSeqList *tlist = NULL;
	if (list == NULL)
	{
		printf("SeqList_Length err\n");
		return -1;
	}
	tlist = (TSeqList*)list;
	return tlist->length;
}

int SeqList_Capacity(SeqList *list)
{
	TSeqList *tlist = NULL;
	if (list == NULL)
	{
		printf("SeqList_Length err\n");
		return -1;
	}
	tlist = (TSeqList*)list;
	return tlist->capacity;
}

int SeqList_Insert(SeqList *list,SeqListNode *node,int pos)
{
	int i = 0;
	TSeqList *tlist = NULL;
	if (list == NULL)
	{
		printf("SeqList_Insert err:list == NULL\n");
		return -1;
	}
	if (node == NULL)
	{
		printf("SeqList_Insert err:node == NULL\n");
		return -2;
	}
	tlist = (TSeqList *)list;
	if (pos <0||pos>tlist->capacity)
	{
		printf("SeqList_Insert err:pos <0||pos>tlist->capacity\n");
		return -3;
	}
	if (pos > tlist->length)
	{
		pos = tlist->length;
	}
	for (i = tlist->length; i > pos; i--)
	{
		tlist->node[i] = tlist->node[i - 1];
	}
	tlist->node[i] = (unsigned int )node;
	tlist->length++;
	return pos;
}

SeqListNode *SeqList_Delete(SeqList *list, int pos)
{
	int i = 0;
	TSeqList *tlist = NULL;
	SeqListNode *ret = NULL;
	if (list == NULL)
	{
		printf("SeqList_Delete err:list == NULL\n");
		return NULL;
	}
	tlist = (TSeqList*)list;
	if (pos <0 || pos>tlist->length)
	{
		printf("SeqList_Insert err:pos <0 || pos>tlist->length\n");
		return NULL;
	}

	ret = (SeqListNode *)tlist->node[pos];
	for (i = pos + 1; i < tlist->length; i++)
	{
		tlist->node[i - 1] = tlist->node[i];
	}
	tlist->length--;
	return ret;
}

SeqListNode* SeqList_Get(SeqList *list, int pos)
{
	int i = 0;
	TSeqList *tlist = NULL;
	if (list == NULL)
	{
		printf("SeqList_Delete err:list == NULL\n");
		return NULL;
	}
	tlist = (TSeqList*)list;
	if (pos <0 || pos>tlist->length)
	{
		printf("SeqList_Insert err:pos <0 || pos>tlist->length\n");
		return NULL;
	}

	return (SeqListNode *)tlist->node[pos];
}

//seqqueue.cpp
#include<stdio.h>
#include"seqqueue.h"

SeqQueue *SeqQueue_Create(int capacity)
{
	return SeqList_Create(capacity);
}

void SeqQueue_Clear(SeqQueue *queue)
{
	SeqList_Clear(queue);
}

void SeqQueue_Destroy(SeqQueue *queue)
{
	SeqList_Destroy(queue);
}

int SeqQueue_Length(SeqQueue *queue)
{
	return SeqList_Length(queue);
}

int SeqQueue_Capacity(SeqQueue *queue)
{
	return SeqList_Capacity(queue);
}

int SeqQueue_Append(SeqQueue *queue, SeqQueue *item)
{
	return SeqList_Insert(queue, item, SeqList_Length(queue));
}

SeqQueue *SeqQueue_Retrieve(SeqQueue *queue)
{
	return SeqList_Delete(queue, 0);
}

SeqQueue *SeqQueue_Header(SeqQueue *queue)
{
	return SeqList_Get(queue, 0);
}

//test.cpp
#include<stdio.h>
#include"seqqueue.h"

void main()
{
	SeqQueue *queue = SeqQueue_Create(20);
	int i = 0;
	int a[5];
	for (i = 0; i < 5; i++)
	{
		a[i] = i + 1;
		SeqQueue_Append(queue, &a[i]);
	}

	printf("capacity:%d\n", (int)SeqList_Capacity(queue));
	printf("length:%d\n", (int)SeqList_Length(queue));
	printf("header:%d\n", *(int*)SeqQueue_Header(queue));

	printf("retrieve:%d\n", *(int *)SeqQueue_Retrieve(queue));
	printf("header:%d\n", *(int*)SeqQueue_Header(queue));

	for (i = 0; i < SeqQueue_Length(queue); i++)
	{
		printf("%d\n", *(int *)SeqQueue_Retrieve(queue));
	}
	SeqQueue_Clear(queue);
	printf("capacity:%d\n", (int)SeqQueue_Capacity(queue));
	printf("length:%d\n", (int)SeqQueue_Length(queue));
	printf("header:%d\n", *(int*)SeqQueue_Header(queue));
	SeqQueue_Destroy(queue);
}

运行结果：

有点奇怪