数据结构——队列

队列是一种操作受限的线性表，只允许在表的前端（front）进行删除操作又称作出队，在表的后端进行插入操作，称为入队，符合先进先出（First in First out）的特性。在队尾插入元素叫做入队，对头删除元素叫做出队。

1.链队列

老师代码

#include <stdio.h>
#include <malloc.h>

/**
 * 链队列的节点.
 */
typedef struct LinkNode{
	int data;
	LinkNode* next;
}*LinkNodePtr;

/**
 * 链队列.
 */
typedef struct LinkQueue{
	LinkNodePtr front;
	LinkNodePtr rear;
}*LinkQueuePtr;

/**
 * Construct an empty queue.
 */
LinkQueuePtr initQueue(){
	LinkQueuePtr resultPtr = (LinkQueuePtr)malloc(sizeof(struct LinkQueue));
	//The header, the data is not useful.
	LinkNodePtr headerPtr = (LinkNodePtr)malloc(sizeof(struct LinkNodePtr));
	headerPtr->next = NULL;
	
	resultPtr->front = headerPtr;
	resultPtr->rear = headerPtr;
	return resultPtr;
}//Of initQueue

/**
 * Output the queue.
 */
void outputLinkQueue(LinkQueuePtr paraQueuePtr){
	LinkNodePtr tempPtr = paraQueuePtr->front->next;
	while (tempPtr != NULL) {
		printf("%d ", tempPtr->data);
		tempPtr = tempPtr->next;
	}//Of while
	printf("\r\n");
}//Of outputLinkQueue

/**
 * Enqueue.
 */
void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) {
	//Step 1. Create a new node
	LinkNodePtr tempNodePtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
	tempNodePtr->data = paraElement;
	tempNodePtr->next = NULL;
	
	//Step 2. Link to the existing rear
	paraQueuePtr->rear->next = tempNodePtr;
	
	//Step 3. It is the new rear
	paraQueuePtr->rear = tempNodePtr;
}//Of enqueue

/**
 * Dequeue.
 * @return The value of the header
 */
int dequeue(LinkQueuePtr paraQueuePtr) {
	int resultValue;
	LinkNodePtr tempNodePtr;

	//Step 1. Is the queue empty?
	if (paraQueuePtr->front == paraQueuePtr->rear) {
		printf("The queue is empty.\r\n");
		return -1;
	}//Of if

	//Step 2. Change the queue.
	tempNodePtr = paraQueuePtr->front->next;
	resultValue = tempNodePtr->data;
	paraQueuePtr->front->next = paraQueuePtr->front->next->next;

	if (paraQueuePtr->rear == tempNodePtr) {
		paraQueuePtr->rear = paraQueuePtr->front;
	}//Of if

	//Step 3. Free space.
	// free(tempNodePtr);
	tempNodePtr = NULL;

	//Step 4. Return.
	return resultValue;
}//Of enqueue
	
/**
 * Unit test.
 */
void testLinkQueue(){
	LinkQueuePtr tempQueuePtr;
	tempQueuePtr = initQueue();
	enqueue(tempQueuePtr, 10);
	enqueue(tempQueuePtr, 30);
	enqueue(tempQueuePtr, 50);

	outputLinkQueue(tempQueuePtr);

	printf("dequeue gets %d\r\n", dequeue(tempQueuePtr));
	printf("dequeue gets %d\r\n", dequeue(tempQueuePtr));
	printf("dequeue gets %d\r\n", dequeue(tempQueuePtr));
	printf("dequeue gets %d\r\n", dequeue(tempQueuePtr));

	enqueue(tempQueuePtr, 8);
	outputLinkQueue(tempQueuePtr);
}//Of testLinkQueue
 
/**
 * The entrance.
 */
int main(){
	testLinkQueue();
	return 1;
}//Of main

我的代码

#include <stdio.h>
#include <stdlib.h>
#define ERROR 0
#define OK 1
typedef int status;
typedef int QElemType;
typedef struct QNode{
	QElemType data;
	struct QNode *next;
}QNode ,*QueuePtr;

typedef struct {
	QueuePtr front, rear;
	int count;
} LinkQueue;


status EnQueue(LinkQueue *q, QElemType e){
	QueuePtr node = (QueuePtr)malloc(sizeof(QNode));
	if (!node) return ERROR;//分配存储失败 
	node->data = e;
	node->next = NULL;
	q->rear->next = node;
	q->rear = node;
	q->count++;
	return OK; 
}

status DeQueue(LinkQueue *q, QElemType *e){
	QueuePtr p;
	if (q->front == q->rear){
		return ERROR;//队列为空 
	}
	p = q->front->next;
	*e = p->data;
	q->front->next = p->next;
	if (q->rear == p){
		q->rear = q->front;
	}
	free(p);
	q->count--;
	return OK;
}

int main(int argc, char const *argv[]){
	//todo
	QNode q = {-1, NULL};
	LinkQueue LQ= {&q, &q, 0};
	printf("链队列的长度为%d\n", LQ.count);
	printf("向链队列中加入元素1/21/32/45/99\n");
	EnQueue(&LQ, 1);
	EnQueue(&LQ, 21);
	EnQueue(&LQ, 32);
	EnQueue(&LQ, 45);
	EnQueue(&LQ, 99);
	printf("链队列的长度为%d\n", LQ.count);
	printf("出依次队列\n");
	int e; 
	DeQueue(&LQ, &e);
	printf("出队列的元素为%d\n", e);
	printf("链队列的长度为%d\n", LQ.count);
	return 0; 
} 

运行结果

2.循环队列

1.老师代码

#include <stdio.h>
#include <malloc.h>

#define TOTAL_SPACE 5

/**
 * Circle int queue.
 */
typedef struct CircleIntQueue{
	int data[TOTAL_SPACE];

	int head;

	int tail;
}*CircleIntQueuePtr;

/**
 * Initialize the queue.
 */
CircleIntQueuePtr initQueue() {
	CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue));
	resultPtr->head = 0;
	resultPtr->tail = 0;

	return resultPtr;
}// Of the first constructor

/**
 * Enqueue.
 * 
 * @param paraValue The value of the new node.
 */
void enqueue(CircleIntQueuePtr paraPtr, int paraValue) {
	if ((paraPtr->tail + 1) % TOTAL_SPACE == paraPtr->head) {
		printf("Queue full.\r\n");
		return;
	} // Of if

	paraPtr->data[paraPtr->tail % TOTAL_SPACE] = paraValue;
	paraPtr->tail++;
}// Of enqueue

/**
 * Dequeue.
 * 
 * @return The value at the head.
 */
int dequeue(CircleIntQueuePtr paraPtr) {
	int resultValue;
	if (paraPtr->head == paraPtr->tail) {
		printf("No element in the queue.\r\n");
		return -1;
	} // Of if

	resultValue = paraPtr->data[paraPtr->head % TOTAL_SPACE];
	paraPtr->head++;

	return resultValue;
}// Of dequeue

/**
 * Output the queue.
 */
void outputLinkQueue(CircleIntQueuePtr paraPtr){
	int i;
	if (paraPtr->head == paraPtr->tail) {
		printf("Empty queue.");
		return;
	} // Of if

	printf("Elements in the queue: ");
	for (i = paraPtr->head; i < paraPtr->tail; i++) {
		printf("%d, ", paraPtr->data[i % TOTAL_SPACE]);
	} // Of for i

	printf("\r\n");
}//Of outputLinkQueue

/**
 * Unit test.
 */
void testLinkQueue(){
	int i = 10;
	CircleIntQueuePtr tempPtr = initQueue();
	for (; i < 16; i ++) {
		enqueue(tempPtr, i);
	}//Of for i

	outputLinkQueue(tempPtr);

	for (i = 0; i < 6; i ++) {
		printf("dequeue gets %d\r\n", dequeue(tempPtr));
	}//Of for i

	enqueue(tempPtr, 8);
	outputLinkQueue(tempPtr);
}//Of testLinkQueue

/**
 * The entrance.
 */
int main(){
	testLinkQueue();
	return 1;
}//Of main

运行结果

Queue full.
Queue full.
Elements in the queue: 10, 11, 12, 13,
dequeue gets 10
dequeue gets 11
dequeue gets 12
dequeue gets 13
No element in the queue.
dequeue gets -1
No element in the queue.
dequeue gets -1
Elements in the queue: 8,
Press any key to continue

我的代码

#include<iostream>
using namespace std;
const int N=1e5+10;
int a[N],hh=0,tt=0;//头指针，尾指针 
const int Maxsize=21;//根据题目范围设定队列长度 ,队列长度要比规定的大 
void push(int x){
	if((tt+1)%Maxsize==hh){//如果队满 
		cout<<"full"<<endl;
		cout<<x<<endl;
		return;
	}
	a[tt]=x;
	tt=(tt+1)%Maxsize; 
	//从队尾进队 
}
bool empty(){//判空 
	if(hh==tt) return true;
	else return false; 
}
int front(){//返回队头元素 
	return a[hh];
}
void pop(){//删除队头元素 
	if(empty()) return;//判断队列是否为空 
	hh=(hh+1)%Maxsize;
} 
int size(){//队列中的元素个数 
	return (tt-hh+Maxsize)%Maxsize;
}
int main(){
	for(int i=1;i<=20;i++)
		 push(i);
	cout<<front()<<endl;
	pop();
	cout<<size();
} 

3.总结

对于循环队列与链队列的比较，可以从两方面来考虑：
    1：从时间上：它们的基本操做的时间复杂度均为O(1)，只不过循环队列是
    实现申请好空间，使用期间不释放，对于链队列，每次申请和释放结点也会
    有一些时间的开销，如果入队列频繁，则还是有细微的差异。
    2：从空间上：循环队列必须有一个固定的长度，所以可能存在空间的浪费
    问题。但是链队列不存在这个问题，虽然其需要指针域，有一些空间上的花
    费，但是是可以接受的。所以在空间上，链队列更灵活。

总的来说：在可以确定队列长度最大值的情况下，建议用循环队列，如果不能确定
最大长度的话，用链队列。