【数据结构】队列的实现

队列

概念

  队列也是一种特殊的线性表, 只允许在一端进行擦汗如操作, 另一端进行删除操作, 元素具有先进先出的特点, 插入操作的一端

叫做队尾, 删除的一段叫做队头.

实现

  队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据

效率会比较低。使用链表的话我们使用尾插和头删, 时间复杂度都是O(1), 效率更高一点. 下面我们就使用链表来实现.

queue.h

#include <stdio.h>
#include <assert.h>

typedef int Datatype;
typedef struct QueueNode
{
	Datatype _data;
	struct QueueNode* _next;
}QueueNode;

typedef struct Queue
{
	struct QueueNode* _front;
	struct QueueNode* _rear;
}Queue;

//初始化
void QueueInit(Queue* q);
//销毁
void QueueDestory(Queue* q);
//创建结点
QueueNode* BuyQueueNode(Datatype x);
//入队
void QueuePush(Queue* q, Datatype x);
//出队
void QueuePop(Queue* q);
//获取队头元素
Datatype QueueFront(Queue* q);
//获取队尾元素
Datatype QueueBack(Queue* q);
//判空
int QueueEmpty(Queue* q);
//判断大小
int QueueSize(Queue* q);
//打印队列
void QueuePrint(Queue* q);

Realize.c

#include "queue.h"

void QueueInit(Queue* q)
{
	assert(q);
	q->_front = NULL;
	q->_rear = NULL;
}

void QueueDestory(Queue* q)
{
	assert(q);
	QueueNode* cur = q->_front;
	while (cur)
	{
		QueueNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	q->_front = q->_rear = NULL;
}

void QueuePush(Queue* q, Datatype x)
{
	assert(q);
	QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
	newNode->_data = x;
	newNode->_next = NULL;
	if (q->_rear == NULL)
	{
		//如果队列现在是空的, q->front 和 q->rear 要同时改变
		q->_rear = q->_front = newNode;
	}
	else
	{
		q->_rear->_next = newNode;
		q->_rear = q->_rear->_next;
	}
}

void QueuePop(Queue* q)
{
	assert(q);
	if (q->_front)
	{
		QueueNode* next = q->_front->_next;
		free(q->_front);
		q->_front = next;
		//如果删除最后一个元素, q->rear也需要变化
		if (q->_front == NULL)
			q->_rear = NULL;
	}
}

Datatype QueueFront(Queue* q)
{
	assert(q);
	if (!QueueEmpty(q))
		return q->_front->_data;
	return -1;
}

Datatype QueueBack(Queue* q)
{
	assert(q);
	return q->_rear->_data;
}

int QueueEmpty(Queue* q)
{
	assert(q);
	return q->_front == NULL;
}

int QueueSize(Queue* q)
{
	assert(q);
	QueueNode* cur = q->_front;
	int count = 0;
	while (cur)
	{
		++count;
		cur = cur->_next;
	}
	return count;
}

void QueuePrint(Queue* q)
{
	assert(q);
	QueueNode* cur = q->_front;
	while (cur)
	{
		printf("%d ", cur->_data);
		cur = cur->_next;
	}
	printf("\n");
}

Test.c

#include "queue.h"

void TestQueue()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePrint(&q);
	Datatype cur = QueueFront(&q);
	printf("front is %d\n", cur);
	cur = QueueBack(&q);
	printf("back is %d\n", cur);
	printf("size is %d\n", QueueSize(&q));
	QueuePop(&q);
	QueuePrint(&q);
	printf("size is %d\n", QueueSize(&q));
	QueueDestory(&q);
}

int main()
{
	TestQueue();
	return 0;	
}

 运行结果