数据结构——队列的实现

队列

1. 队列的概念及结构
   1.1 概念
   队列：只允许在一端对数据进行插入，另一端进行删除的特殊线性表。

队列具有先进先出的特性

1. 2

实现
与栈类似队列也可以用数组和链表的结构实现。

使用链表为更优选。因为使用数组会降低效率

1. 3 队列的具体实现
   使用带头结点的单链表实现：

typedef int QDataType;
// 链式结构：表示队列 
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
}Queue;

//创建申请空间的函数
QNode *BuyNode(QDataType x){
	QNode *newnode = (QNode*)malloc(sizeof(QNode));
	if (!newnode){
		assert(0);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* q){
	return q->front == q->rear;
}
// 初始化队列 
void QueueInit(Queue* q){
	assert(q);
	QNode *head = BuyNode(0);
	q->front = head;
	q->rear = head;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data){
	assert(q);
	QNode* node = BuyNode(data);
	q->rear->next = node;
	q->rear = node;
}
// 队头出队列 
void QueuePop(Queue* q){
	assert(q);
	//判断队列是否为空
	if (QueueEmpty(q)){
		return;
	}
	QNode* tmp = q->front->next;
	if (tmp == q->rear){
		q->front->next = NULL;
		q->rear = q->front;
	}
	else{
		q->front->next = tmp->next;
	}
	free(tmp);
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q){
	assert(q);
	if (QueueEmpty(q))
		return (QDataType)0;
	return q->front->next->data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q){
	assert(q);
	if (QueueEmpty(q))
		return (QDataType)0;
	return q->rear->data;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q){
	assert(q);
	int i = 0;
	QNode* cur = q->front->next;
	while (cur){
		i++;
		cur = cur->next;
	}
	return i;
}
// 销毁队列 
void QueueDestroy(Queue* q){
	while (q->front){
		QNode* cur = q->front;
		q->front = q->front->next;
		free(cur);
	}
}

特殊的队列：

环形队列：可以用数组实现也可以用循环链表实现。

其中空队列和满队列的判断较为模糊，所以有：

为了可使Q.front=Q.rear判断对空还是队满，认为2图出现的情况为队满，即此时有:rear+1=front

环形队列的实现：

结点的实现

typedef struct {
    int* queue;
    int front;
    int rear
    int k;
} MyCircularQueue;

主体实现：

//创建循环链表
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* pcq=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    pcq->queue=(int*)malloc(sizeof(int)*(k+1));
    pcq->front=0;
    pcq->rear=0;
    pcq->k=k;
    return pcq;
}
//插入队列
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if((obj->rear+1)%(obj->k+1)==obj->front){
        return false;
    }
    obj->queue[obj->rear++]=value;
    if(obj->rear==obj->k+1){
        obj->rear=0;
    }
    return true;
}
//删除元素
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(obj->front==obj->rear){
        return false;
    }
    ++obj->front;
    if(obj->front==obj->k+1){
        obj->front=0;
    }
    return true;
}
//取对头元素
int myCircularQueueFront(MyCircularQueue* obj) {
    if(obj->front==obj->rear){
        return -1;
    }else{
        return obj->queue[obj->front];
    }
}
//取队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    if(obj->front==obj->rear){
        return -1;
    }
    if(obj->rear==0){
        return obj->queue[obj->k];
    }else{
        return obj->queue[obj->rear-1];
    }
}
//检测
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front==obj->rear;
}
//检查是否队列满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return(obj->rear+1)%(obj->k+1)==obj->front;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->queue);
    free(obj);
}