队列数据结构

队列

队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出

FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头

队列的实现

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

大概思路

// 链式结构：表示队列 

typedef struct QListNode 
{ 
 struct QListNode* _pNext; 
 QDataType _data; 
}QNode; 
 

// 队列的结构 

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

// 初始化队列 

void QueueInit(Queue* q); 

// 队尾入队列 

void QueuePush(Queue* q, QDataType data); 

// 队头出队列 

void QueuePop(Queue* q); 

// 获取队列头部元素 

QDataType QueueFront(Queue* q); 

// 获取队列队尾元素 

QDataType QueueBack(Queue* q); 

// 获取队列中有效元素个数 

int QueueSize(Queue* q); 

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 

int QueueEmpty(Queue* q); 

// 销毁队列 

void QueueDestroy(Queue* q);

代码

链式结构：表示队列

typedef char QDatatype;

typedef struct QueueNode
{
	struct QueueNode* next;
	QDatatype data;
}QNode

队列的结构

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;;

void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDatatype x);
void QueuePop(Queue* pq);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);
QDatatype QueueFront(Queue* pq);
QDatatype QueueBack(Queue* pq);

初始化

void QueueInit(Queue* pq);

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head= NULL;
	pq->tail= NULL;
	pq->size = 0;
}

销毁

void QueueDestroy(Queue* pq);

//销毁
void QueueDestroy(Queue* pq)
{
	while (pq->head)
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

插入，因为是先进先出，所以要尾插头出，想想单链表的结构

void QueuePush(Queue* pq, QDatatype x);

void QueuePush(Queue* pq, QDatatype x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->head==NULL)
	{
		assert(pq->tail == NULL);
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

删除，就是出，先进先出，在链表中是头删

void QueuePop(Queue* pq);

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head != NULL);

	//只有一个时
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}

获取队列中有效元素个数 

int QueueSize(Queue* pq);

int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

检测队列是否为空，如果为空返回非零结果，如果非空返回0 

bool QueueEmpty(Queue* pq);

//法1
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* pq)
{

	if (pq->size != 0)
	{
		return false;
	}
	else
	return true;
}

//法二
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->size == 0;
}

获取队列头部元素 

QDatatype QueueFront(Queue* pq);

QDatatype QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}

获取队列队尾元素 

QDatatype QueueBack(Queue* pq);

QDatatype QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}