队列基本操作

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出
FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头
Queue.h

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#include<stdlib.h>
typedef int QUDataType;

typedef struct QueueNode
{
	QUDataType _data;
	struct QueueNode* _next;
}QueueNode;

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

void QueueInit(Queue* q);
void QueueDestory(Queue* q);

void QueuePush(Queue* q, QUDataType x);
void QueuePop(Queue* q);
int QueueSize(Queue* q);
int QueueEmpty(Queue* q);
QUDataType QueueFront(Queue* q);
QUDataType QueueBack(Queue* q);

void QueuePrint(Queue* q);

//队列的Pop实现是，先对队头进行判空，判空后，在对一个节点在分别处理，在删除节点后，把队尾置空

Queue.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "queue.h"

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

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

QueueNode* QueueBuyNode(x)
{
	QueueNode* newnode = NULL;
	newnode = (QueueNode*)malloc(sizeof(QueueNode));
	newnode->_data = x;
	newnode->_next = NULL;
	return newnode;
}
void QueuePush(Queue* q, QUDataType x)
{
	assert(q);
	if (q->_front == NULL)
	{
		QueueNode* newnode = QueueBuyNode(x);
		q->_front = newnode;
		q->_rear = newnode;
	}
	else
	{
		QueueNode* newnode = QueueBuyNode(x);
		q->_rear->_next = newnode;
		q->_rear = newnode;
	}
}

void QueuePop(Queue* q)
{
	QueueNode* cur = NULL;
	assert(q);
	if (q->_front != NULL)
	{
		cur = q->_front->_next;
		free(q->_front);
		q->_front = cur;
		if (q->_front == NULL)
		{
			q->_rear = NULL;
		}
	}

}

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

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

QUDataType QueueFront(Queue* q)
{
		return q->_front->_data;
}
QUDataType QueueBack(Queue* q)
{
		return q->_rear->_data;
}

void QueuePrint(Queue* q)
{
	assert(q);
	while (QueueEmpty(q))
	{
		printf("%d ", QueueFront(q));
		QueuePop(q);
	}
}

猜你喜欢