队列的顺序存储和链式存储

        队列是一种先进先出的线性表；它只允许在一端插入元素，在另外一端删除元素；允许插入元素的一端叫做队尾，允许删除元素的一端叫做队头。

1.顺序存储

//头文件.h

#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#ifndef _MY_SEQLIST_H_ 
#define _MY_SEQLIST_H_
typedef void SeqList;
typedef void SeqListNode;

//创建并且返回一个空的线性表
SeqList* Seqlist_Create(int capacity);

//销毁一个线性表
void  SeqList_Destroy(SeqList* list);

//将一个线性表list中的所有元素清空, 线性表回到创建时的初始状态 
void SeqList_Clear(SeqList* list);

//返回一个线性表list中的所有元素个数 
int  SeqList_Length(SeqList* list);

//返回一个线性表list中的容量
int SeqList_capacity(SeqList* list);

//向一个线性表list的pos位置处插入新元素node 
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

//获取一个线性表list的pos位置处的元素
SeqListNode* Seqlist_Get(SeqList* list, int pos);

//删除一个线性表list的pos位置处的元素返回值为被删除的元素，NULL表示删除失败 
SeqListNode* Seqlist_Delete(SeqList* list, int pos);

#endif

#ifndef _MY_SEQQUEUE_H_
#define _MY_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 // !SEQQUEUE

//函数实现.c

#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#include"Seqlist.h"

typedef struct _tag_Seqlist
{
	int length;//长度
	int capacity;//容量
	unsigned int* node;//数组
}TSeqlist;


//创建并且返回一个空的线性表
SeqList* Seqlist_Create(int capacity)
{   //创建线性表
	int ret = 0;
	TSeqlist *tmp=NULL;
	tmp = (TSeqlist *)malloc(sizeof(TSeqlist));
	if (tmp==NULL)
	{
		ret = -1;
		printf("func:Seqlist_Create err%d\n",ret);
		return NULL;
	}
	memset(tmp, 0, sizeof(TSeqlist));
	//根据capacity大小分配结点的空间
	tmp->node = (unsigned int *)malloc(sizeof(unsigned int *) * capacity);
	if (tmp->node == NULL)
	{
		ret = -2;
		printf("func:Seqlist_Create err:malloc err %d\n", ret);
		return NULL;
	}
	tmp->capacity = capacity;
	tmp->length = 0;
	return tmp;
}
//销毁一个线性表
void  SeqList_Destroy(SeqList* list)
{
	TSeqlist *tlist=NULL;
	if (list == NULL)
	{
		return ;
	}
	tlist = (TSeqlist *)list;//强制转换
	if (tlist->node!=NULL)
	{
		free(tlist->node);
	}
	free(tlist);
	return ;
}
//将一个线性表list中的所有元素清空, 线性表回到创建时的初始状态 
void SeqList_Clear(SeqList* list)
{
	TSeqlist *tlist = NULL;
	if (list == NULL)
	{
		return ;
	}
	tlist = (TSeqlist *)list;
	tlist->length = 0;
	return;
}
//返回一个线性表list中的所有元素个数 
int  SeqList_Length(SeqList* list)
{
	TSeqlist *tlist = NULL;
	if (list == NULL)
	{
		return -1;
	}
	tlist = (TSeqlist *)list;
	return  tlist->length;
}

//返回一个线性表list中的容量
int SeqList_capacity(SeqList* list)
{
	TSeqlist *tlist = NULL;
	if (list == NULL)
	{
		return -1;
	}
	tlist = (TSeqlist *)list;
	return  tlist->capacity;
	return 0;
}
//向一个线性表list的pos位置处插入新元素node 
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
	int i = 0, ret = 0;
	TSeqlist *tlist = NULL;
	
	if (list == NULL || node==NULL || pos<0)
	{
		ret = -1;
		printf("SeqList_Insert err%d\n",ret);
		return ret;
	}
	tlist = (TSeqlist *)list;

	//判断是不是满了
	if (tlist->length>=tlist->capacity)
	{
		ret = -2;
		printf("Func:SeqList_Insert err :tlist->length>=tlist->capacity err %d\n", ret);
		return ret;
	}

	//容错修正
	if (pos >= tlist->length)
	{
		pos = tlist->length;
	}

	//元素后移
	for ( i = tlist->length; i > pos; i--)
	{
		tlist->node[i] = tlist->node[i - 1];
	}

	//元素插入
	tlist->node[pos] = (unsigned int)node;
	tlist->length++;
	return 0;
}
//获取一个线性表list的pos位置处的元素
SeqListNode* Seqlist_Get(SeqList* list, int pos)
{
	int i = 0;
	SeqListNode *ret = 0;
	TSeqlist *tlist = NULL;

	if (list == NULL || pos<0)
	{
		printf("Func:Seqlist_Get err%d\n", ret);
		return ret;
	}
	tlist = (TSeqlist *)list;
	ret = tlist->node[pos];
	return ret ;
}
//删除一个线性表list的pos位置处的元素返回值为被删除的元素，NULL表示删除失败 
SeqListNode* Seqlist_Delete(SeqList* list, int pos)
{
	int i = 0;
	SeqListNode *ret = 0;
	TSeqlist *tlist = NULL;

	//检查
	if (list == NULL || pos<0)
	{
		printf("SeqList_Insert err%d\n", ret);
		return ret;
	}
	tlist = (TSeqlist *)list;

	//缓存pos位置
	ret = (SeqListNode *)tlist->node[pos];

	//元素前移
	for (i = pos + 1; i < tlist->length; i++)
	{
		tlist->node[i-1] = tlist->node[i];
	}
	tlist->length--;
	return ret;
}

#include<stdio.h>
#include<stdlib.h>
#include"SeqQueue.h"
#include"Seqlist.h"


SeqQueue* SeqQueue_Create(int capacity)
{
	return Seqlist_Create(capacity);
}
void  SeqQueue_Destroy(SeqQueue* queue)
{
	SeqList_Destroy(queue);
}
void SeqQueue_Clear(SeqQueue* queue)
{
	 SeqList_Clear(queue) ;
}
int SeqQueue_Append(SeqQueue* queue, void* item)
{
	return SeqList_Insert(queue, item, SeqList_Length(queue));
	
}
void* SeqQueue_Retrieve(SeqQueue* queue)
{
	return Seqlist_Delete(queue,0);
}
void* SeqQueue_Header(SeqQueue* queue)
{
	return Seqlist_Get(queue,0);
}
int SeqQueue_Length(SeqQueue* queue)
{
	return SeqList_Length(queue);
}
int SeqQueue_Capacity(SeqQueue* queue)
{
	return SeqList_capacity(queue);
}

//测试.c

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"Seqlist.h"
#include"SeqQueue.h"
int main()
{
	int  a[10];
	SeqQueue* queue = NULL;
	queue = SeqQueue_Create(10);
	if (queue == NULL)
	{
		return;
	}
	for (int i = 0; i < 10; i++)
	{
		a[i] = i;
		SeqQueue_Append(queue,&a[i]);
	}
	printf("length=%d\n",SeqQueue_Length(queue)   );
	printf("capacity=%d\n", SeqQueue_Capacity(queue)  );
	printf("header=%d\n", *((int *)SeqQueue_Header(queue))   );

	while (SeqQueue_Length(queue)>0)
	{
		int temp= *((int *)SeqQueue_Retrieve(queue));
		printf("%d\n", temp);
	}
	SeqList_Destroy(queue);
	system("pause");
	return 0;
}

2.链式存储

//头文件h

#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#ifndef _MY_LINKLIST_H_ 
#define _MY_LINKLIST_H_
typedef void LinkList;
//typedef void LinkListNode;

typedef struct _tag_LinkListNode
{
	struct _tag_LinkListNode* next;
}LinkListNode;

//创建并且返回一个空的线性表
LinkList* LinkList_Create();

//销毁一个线性表
void  LinkList_Destroy(LinkList* list);

//将一个线性表list中的所有元素清空, 线性表回到创建时的初始状态 
void LinkList_Clear(LinkList* list);

//返回一个线性表list中的所有元素个数 
int  LinkList_Length(LinkList* list);

//向一个线性表list的pos位置处插入新元素node 
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);

//获取一个线性表list的pos位置处的元素
LinkListNode* LinkList_Get(LinkList* list, int pos);

//删除一个线性表list的pos位置处的元素返回值为被删除的元素，NULL表示删除失败 
LinkListNode* LinkList_Delete(LinkList* list, int pos);


#endif

#ifndef _MY_LINKQUEUE_H_
#define _MY_LINKQUEUE_H_

typedef void  LinkQueue;

LinkQueue*  LinkQueue_Create(int capacity);
void LinkQueue_Destroy(LinkQueue* queue);
void LinkQueue_Clear(LinkQueue* queue);
int LinkQueue_Append(LinkQueue* queue,void* item);
void* LinkQueue_Retrieve(LinkQueue* queue);
void* LinkQueue_Header(LinkQueue* queue);
int LinkQueue_Length(LinkQueue* queue);



#endif // !_MY_LINKQUEUE_H_

//函数实现c

#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#include"LinkList.h"
typedef struct LinkList
{
	LinkListNode header;
	int length;
}TLinkList;
//创建并且返回一个空的线性表
LinkList* LinkList_Create()
{
	TLinkList *tmp = NULL;
	tmp = (TLinkList*)malloc(sizeof(TLinkList));
	memset(tmp, 0, sizeof(TLinkList));

	tmp->length = 0;
	tmp->header.next = NULL;
	return tmp;
}

//销毁一个线性表
void  LinkList_Destroy(LinkList* list)
{
	if (list != NULL)
	{
		free(list);
		list = NULL;
	}
	return ;
}

//将一个线性表list中的所有元素清空, 线性表回到创建时的初始状态 
void LinkList_Clear(LinkList* list)
{
	TLinkList *tlist = NULL;
	if (list == NULL)
	{
		return;
	}
	tlist = (TLinkList *)list;
	tlist->length = 0;
	tlist->header.next = NULL;
	
	return ;
}

//返回一个线性表list中的所有元素个数 
int  LinkList_Length(LinkList* list)
{
	TLinkList *tlist = NULL;
	if (list == NULL)
	{
		return;
	}
	tlist = (TLinkList *)list;

	return tlist->length;
}

//向一个线性表list的pos位置处插入新元素node 

//指针指向谁就把谁的地址给指针
//分清 链表的操作逻辑和 辅助指针变量之间的关系
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)
{
	int i = 0, ret = 0;
	LinkListNode* current=NULL;
	TLinkList *tlist = NULL;
	if (list == NULL||node==NULL||pos<0)
	{
		ret = -1;
		printf("Func:LinkList_Insert err%d\t",ret);
		return ;
	}
	tlist = (TLinkList *)list;
	current = &(tlist->header);
	for (i = 0; i < pos ; i++)
	{
		current = current->next;
	}

	//将node的next指向下一个元素的首地址
	    node->next=current->next;
	//将上一个元素的next指向node的首地址
	    current->next=node;

	    tlist->length++;
	return 0;
}

//获取一个线性表list的pos位置处的元素
LinkListNode* LinkList_Get(LinkList* list, int pos)
{
	int i = 0, ret = 0;
	LinkListNode* current = NULL;
	TLinkList *tlist = NULL;
	if (list == NULL || pos<0)
	{
		ret = 0;
		printf("Func:LinkList_Insert err%d\t", ret);
		return NULL;
	}
	tlist = (TLinkList *)list;
	current = &(tlist->header);
	for (i = 0; i < pos && (current->next != NULL); i++)
	{
		current = current->next;
	}

	return  current->next;
}

//删除一个线性表list的pos位置处的元素返回值为被删除的元素，NULL表示删除失败 
LinkListNode* LinkList_Delete(LinkList* list, int pos)
{
	int i = 0, ret = 0;
	LinkListNode* current = NULL;
	LinkListNode* tmp = NULL;
	TLinkList *tlist = NULL;
	if (list == NULL || pos<0)
	{
		ret = -1;
		printf("Func:LinkList_Insert err%d\t", ret);
		return;
	}
	tlist = (TLinkList *)list;
	current = &(tlist->header);
	for (i = 0; i < pos && (current->next != NULL); i++)
	{
		current = current->next;
	}

	//将删除元素nodede首地址找出来
	tmp = current->next;
	//将删除元素node的下一个元素的首地址赋给上一个元素的next
	current->next = tmp->next;
	tlist->length--;
	return tmp;//返回删除元素的地址
}

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"LinkList.h"
#include"LinkQueue.h"
typedef struct _tag_LinkQueueNode_//队列结点
{
	LinkListNode node;//链表结点
	void* item;
}TLinkQueueNode;

//建立队列：建立一个线性表；
LinkQueue*  LinkQueue_Create(int capacity)
{
	return LinkList_Create(capacity);
}
//销毁之前要先清空；
void LinkQueue_Destroy(LinkQueue* queue)
{
	LinkQueue_Clear(queue);
	LinkList_Destroy(queue);
}
//清空时需要将每个结点拿出来，并释放结点
void LinkQueue_Clear(LinkQueue* queue)
{
	while (LinkQueue_Length(queue) > 0)
	{
		LinkQueue_Retrieve(queue);//已释放
	}
	LinkList_Clear(queue);
}
//入队列：在线性表的尾部插入元素
int LinkQueue_Append(LinkQueue* queue, void* item)
{
	//建立一个队列结点
	int ret = 0;
	TLinkQueueNode * tmp = NULL;
	tmp = (TLinkQueueNode *)malloc(sizeof(TLinkQueueNode));
	if (tmp == NULL)
	{
		 ret = -1;
		printf("Func:LinkQueue_Append malloc error%d",ret);
		return ret;
	}
	memset(tmp,0,sizeof(TLinkQueueNode));
	tmp->item = item;
	//结点转换
	ret=LinkList_Insert(queue,(LinkListNode*)tmp,LinkList_Length(queue));
	if (ret != 0)
	{
		printf("Func:LinkList_Insert err%d",ret);
		if (tmp != NULL)
			free(tmp);
		return ret;
	}
	return ret;
}
//出队列：从线性表的0号位置删除
void* LinkQueue_Retrieve(LinkQueue* queue)
{
	TLinkQueueNode * tmp = NULL;
	void *ret = NULL;
	tmp = (TLinkQueueNode *)LinkList_Delete(queue,0);
	if (tmp == NULL)
	{
		printf("Func:LinkList_Delete() err%d\n");
		return NULL;
	}
	//删除前缓存并返回
	ret = tmp->item;
	if (tmp != NULL)
	{
		free(tmp);
	}
	return ret;
}
//获取头部元素：线性表的0号位置
void* LinkQueue_Header(LinkQueue* queue)
{
	TLinkQueueNode * tmp = NULL;
	void *ret = NULL;
	tmp = (TLinkQueueNode *)LinkList_Get(queue, 0);
	if (tmp == NULL)
	{
		printf("Func:LinkList_Get() err%d\n");
		return NULL;
	}
	ret = tmp->item;
	return ret;
}
//获取队列长度：线性表的长度
int LinkQueue_Length(LinkQueue* queue)
{
	return LinkList_Length(queue);
}

//测试c

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"LinkList.h"
#include"LinkQueue.h"
int main()
{
	int  a[10];
	LinkQueue* queue = NULL;
	queue = LinkQueue_Create(10);
	if (queue == NULL)
	{
		return 0;
	}
	for (int i = 0; i < 10; i++)
	{
		a[i] = i;
		LinkQueue_Append(queue, &a[i]);
	}
	printf("length=%d\n", LinkQueue_Length(queue));
	printf("header=%d\n", *((int *)LinkQueue_Header(queue)));

	while (LinkQueue_Length(queue)>0)
	{
		int temp = *((int *)LinkQueue_Retrieve(queue));
		printf("%d\n", temp);
	}
	LinkQueue_Destroy(queue);
	system("pause");
	return 0;
}