队列算法【基于顺序表的环形队列、基于链表的环形队列】

一、基于顺序标的环形队列

代码如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*【环形缓冲区（顺序表版本）】*/
typedef struct
{
	int* data;
	int size;
}g_tVector;
/* 顺序表的初始化 */
void VectorInit(g_tVector* vector, int len)
{
	if (NULL == vector)  return;
	vector->data = (int*)malloc(sizeof(int) * len);
	vector->size = len;
	return;
}
/* 顺序表的清理 */
void VectorClear(g_tVector* vector)
{
	if (NULL == vector)  return;
	free(vector->data);
	return;
}
/* 顺序表的写入数据 */
bool VectorWrite(g_tVector* vector, int index , int data)
{
	if (NULL == vector)  return false;
	vector->data[index] = data;
	return true;
}
/* 顺序表的读出数据 */
bool VectorRead(g_tVector* vector, int index, int** data)
{
	if (NULL == vector)  return false;
	**data = vector->data[index];
	return true;
}

/************************************************/
typedef struct
{
	g_tVector* vector;
	int count, head, tail, len;
	void (*vectorInit)(g_tVector*, int);
	void (*vectorClear)(g_tVector*);
	bool (*vectorWrite)(g_tVector*, int, int);
	bool (*vectorRead)(g_tVector*, int, int**);
}g_tQueue;

/* 环形缓冲区的初始化 */
void QueueInit(g_tQueue* queue, int len)
{
	if (NULL == queue) return;
	queue->vector = (g_tVector*)malloc(sizeof(g_tVector));
	queue->vectorInit = VectorInit;
	queue->vectorClear = VectorClear;
	queue->vectorRead = VectorRead;
	queue->vectorWrite = VectorWrite;
	queue->vectorInit(queue->vector, len);
	queue->len = len;
	queue->head = queue->tail = queue->count = 0;
	printf("init:%d, %d, %d, %d\r\n", queue->len, queue->count, queue->head, queue->tail);
	return;
}

/* 环形缓冲区申请内存的释放 */
void QueueClear(g_tQueue* queue)
{
	if (NULL == queue) return;
	VectorClear(queue->vector);
	free(queue->vector);
	free(queue);
	return;
}

bool QueueIsEmpty(g_tQueue* queue)
{
	if (NULL == queue) return false;
	return (queue->count == 0);
}

bool QueueIsFull(g_tQueue* queue)
{
	if (NULL == queue) return false;
	//printf("data:%d, %d\r\n", queue->count, queue->len);
	return (queue->count == queue->len);
}

/* 从环形缓冲区取出数据 */
bool PopQueue(g_tQueue* queue, int* data)
{
	if ((NULL == queue)|| (NULL == data) || QueueIsEmpty(queue)) return false;
	queue->vectorRead(queue->vector, queue->head, &data);
	if (queue->head < queue->len-1)
		queue->head++;      //头部索引向后移动
	else
		queue->head = 0;    //头部指向尾部
	queue->count--;   //环形缓冲区存储的数据量
	return true;
}
/* 向环形缓冲区压入数据 */
bool PushQueue(g_tQueue* queue, int data)
{
	if ((NULL == queue) || QueueIsFull(queue)) return false;
	queue->vectorWrite(queue->vector, queue->tail, data);
	if (queue->tail < queue->len-1)
		queue->tail++;
	else
		queue->tail = 0;
	queue->count++;
	return true;
}


int main()
{
	g_tQueue queue;
	bool ret;
	int data;
	QueueInit(&queue, 5);
	for (int i = 0; i < 6; i++)
	{
		data = rand() % 100;
		ret = PushQueue(&queue, data);
		if (!ret)
			printf("%d push is error\r\n", i);
		else
			printf("push %d\r\n", data);
	}
	ret = PopQueue(&queue, &data);
	if (ret)
		printf("pop data is %d\r\n", data);
	return 0;
}

运行结果如下所示：

二、基于链表的环形队列

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
/* 队列的实现（基于链表形式的） */
/* 链表的节点 */
typedef struct Node
{
	int data;
	Node* next;
}g_tNode;


//链表的管理结构体，利用链表的头尾节点
typedef struct
{
	g_tNode* head, * tail;
}g_tList;

//链表的初始化
g_tList* ListInit(g_tList *list)
{
	if (NULL == list) return NULL;
	list = (g_tList*)malloc(sizeof(g_tList));
	list->tail = NULL;
	list->head = NULL;
	return list;
}

//链表的清除
bool ListFree(g_tList* list)
{
	if (NULL == list) return false;
	g_tNode* node1 = list->head, *node2;
	while (node1)
	{
		node2 = node1->next;
		free(node1);
		node1 = node2;
	}
	free(list);
	return true;
}

//创建一个链表节点
g_tNode* GetNode(int data)
{
	g_tNode* ret;
	ret = (g_tNode*)malloc(sizeof(g_tNode));
	ret->data = data;
	ret->next = NULL;
	return ret;
}

//向链表的后面插入一个节点
bool ListInsertNode(g_tList* list, int data)
{
	if (NULL == list) return false;
	g_tNode* node = GetNode(data);
	if (NULL == list->head) list->head = node;
	list->tail = node;
	list->tail = list->tail->next;
	return true;
}

//清除链表前面的一个节点
bool ListGetNode(g_tList* list, int** data)
{
	g_tNode* node = list->head;
	if ((NULL == list)||(NULL == list->head)) return false;
	**data = list->head->data;
	list->head = list->head->next;
	free(node);
	return true;
}

/*****************************************************************/
typedef struct
{
	g_tList* list;
	int count;
}g_tQueue;

//链表初始化
bool QueueInit(g_tQueue* queue)
{
	if (NULL == queue) return false;
	queue->list = (g_tList*)malloc(sizeof(g_tList));
	queue->list = ListInit(queue->list);
	queue->count = 0;
	return true;
}


//将数据压入队列中
bool QueuePush(g_tQueue* queue, int data)
{
	bool ret;
	if (NULL == queue) return false;
	ret = ListInsertNode(queue->list, data);
	if (ret) queue->count += 1;
	return ret;
}


//从队列中取出数据
bool QueuePop(g_tQueue* queue, int* data)
{
	bool ret;
	if (NULL == queue) return false;
	ret = ListGetNode(queue->list, &data);
	if (ret) queue->count -= 1;
	return ret;
}

void QueueClear(g_tQueue* queue)
{
	if (NULL == queue) return;
	ListFree(queue->list);
	free(queue->list);
	return;
}


int main()
{
	int data;
	bool ret;
	g_tQueue queue;
	QueueInit(&queue);
	for (int i = 0; i < 5; i++)
	{
		data = rand() % 100;
		ret = QueuePush(&queue, data);
		if(ret)
			printf("push: %d\r\n", data);
	}
	ret = QueuePop(&queue, &data);
	printf("pop: %d\r\n", data);

	return 0;
}

运行结果如下所示：