DS_2019_5_13(队列Queue)

生命是一种缘,你刻意追求的东西也许终身得不到,
而你不曾期遇的灿烂,反而会在你的淡泊从容中不期而遇!

1. 队列(queue)

1.1 定义

只允许在一端进行插入数据操作,在另外一端进行删除操作的特殊线性表.允许插入的端是队尾，允许删除的端是队头。

1.2 特性

先进先出(FIFIO)

1.3 队列的接口实现

• 获取队列;
• 初始化;
• 入队列;
• 出队列;
• 获取队头元素;
• 获取队尾元素;
• 元素数量;
• 判空;
• 销毁;

1.4 队列的分类分类

顺序队列
循环队列
双端队列

1.5 队列的应用场景

(1)离散模拟离职

1.6 代码实现

1. Queue.h

#pragma once

typedef int	QDataType;

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

typedef struct Queue{
	QNode* _front;                    //指向对头元素
	QNode* _back;                     //指向队尾元素
}Queue;

//获取结点
QNode* BuyQueueNode(QDataType data);

//初始化
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);

//判空
int QueueEmpty(Queue* q);

//销毁
void QueueDestroy(Queue* q);

//测试
void TestQueue();

2. Queue.c

#include "Queue.h"
#include <malloc.h>
#include <assert.h>
#include <stdio.h>

//获取结点

QNode* BuyQueueNode(QDataType data){
	QNode* pNewNode = (QNode*)malloc(sizeof(QNode));
	if (NULL == pNewNode){
		assert(0);
		return NULL;
	}
	pNewNode->_data = data;
	pNewNode->_pNext = NULL;
	return pNewNode;
}

//初始化

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

//入队列

void QueuePush(Queue* q, QDataType data){
	assert(q);
	QNode* pNewNode = BuyQueueNode(data);
	if (QueueEmpty(q))
		q->_front = q->_back = pNewNode;
	else{
		q->_back->_pNext = pNewNode;
		q->_back = pNewNode;
	}
}

//出队列

void QueuePop(Queue* q){
	QNode* pDelNode = NULL;
	if (QueueEmpty(q))
		return;

	pDelNode = q->_front;
	if (NULL == pDelNode->_pNext){
		q->_front = q->_back = NULL;
	}
	else{
		q->_front = pDelNode->_pNext;
	}

	free(pDelNode);
}

//获取对头元素

QDataType QueueFront(Queue* q){
	assert(q);
	return q->_front->_data;
}

//获取队尾元素

QDataType QueueBack(Queue* q){
	assert(q);
	return q->_back->_data;
}

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

int QueueSize(Queue* q){
	int count = 0;
	QNode* pCur = q->_front;
	while (pCur){
		count++;
		pCur = pCur->_pNext;
	}
    return count;
}

//判空

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

//销毁

void QueueDestroy(Queue* q){
	QNode* pCur = q->_front;
	while (pCur){
		q->_front = pCur->_pNext;
		free(pCur);
		pCur = q->_front;
	}

	q->_front = q->_back = NULL;
}

//检测

void TestQueue(){
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	printf("front = %d\n", QueueFront(&q));
	printf("back = %d\n", QueueBack(&q));
	printf("size = %d\n", QueueSize(&q));

	QueuePop(&q);
	printf("front = %d\n", QueueFront(&q));
	printf("back = %d\n", QueueBack(&q));
	printf("size = %d\n", QueueSize(&q));

	QueuePop(&q);
	QueuePop(&q);
	printf("front = %d\n", QueueFront(&q));
	printf("back = %d\n", QueueBack(&q));
	printf("size = %d\n", QueueSize(&q));

	QueuePop(&q);
	printf("size = %d\n", QueueSize(&q));
	QueueDestroy(&q);
}

3. test.c

#include "Queue.h"

int main(){
	TestQueue();
	system("pause");
	return 0;
}

4.运行结果:

front = 1
back = 4
size = 4
front = 2
back = 4
size = 3
front = 4
back = 4
size = 1
size = 0