数据结构之队列(FIFO)

一、队列的认识:

首先,队列和栈有点类似,他是一种类似于排队的容器或者说一种先进先出的数学逻辑.

其次,由于他也是一种抽象的逻辑模型,所以我们也需要借助数组或者链表去实现.

二、队列的实现:

1)基于数组的顺序队列:

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
//基于数组的队列：数组尾添加，数组头删除；
#define Length 10
typedef enum {
	false,
	true
}bool;

int queue[Length] = { 0 };//作为队列的容器；

//作为队列的头，尾，全为-1时，队列为空；
int front = -1;
int tail = -1;

//添加队尾数据（链表尾）
void Enqueue(int n) {
	if (front == -1 && tail == -1) {
		front = tail = 0;
		queue[front] = n;
		return;
	}
	if (IsFull() ){
		return;
	}
	//队列不满：1.front前有空间；2.tail后有空间
	tail += 1;
	queue[tail] = n;
}
//删除队头数据（链表头）
void Dequeue() {
	if (front == -1 && tail == -1) {
		return;
	}
	if (front == tail) {
		front = tail = -1;
		return;
	}
	front = front + 1;
}
//返回链表头数据（队首数据）
int Front()
{
	if (IsEmpty()) {
		return -1;
	}
	else {
		return queue[front];
	}
}
//判断队列是否为空；
bool IsEmpty()
{
	if (front == -1 && tail == -1) {
		return true;
	}
	return false;
}

bool IsFull() {
	//这里front == 0，是为了保证充分利用空间，可以通过循环队列去添加元素；

	//作为简单队列时的判满条件；
	if (tail % Length == 0&&front == 0 &&tail!=front) {
		return true;
	}
	else {
		return false;
	}

	//作为循环队列时的判满条件；
		/*if ((tail + 1) % Length == front) {
			return true;
		}
		else {
			return false;
		}*/
}

void printqueue() {
	for (int i = front; i <= tail; i++) {
		printf("%d ", queue[i]);
	}
	puts("");
	return;
}

int main() {
	Enqueue(1);
	printqueue();
	printf("队列头：%d\n", Front());
	Enqueue(2);
	printqueue();
	Enqueue(3);
	printqueue();
	printf("队列头：%d\n", Front());             
	Enqueue(4);
	printqueue();
	Enqueue(5);
	printqueue();
	Dequeue();
	printqueue();
	Dequeue();
	printqueue();
	printf("队列头：%d\n", Front());

	return 0;
}

2)基于链表的线性队列:

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>

//基于数组的队列：数组尾添加，数组头删除；
#define Length 10
typedef enum {
	false,
	true
}bool;

int queue[Length] = { 0 };//作为队列的容器；

//作为队列的头，尾，全为-1时，队列为空；
int front = -1;
int tail = -1;

//添加队尾数据（链表尾）
void Enqueue(int n) {
	if (IsEmpty()) {
		front = tail = 0;
		queue[front] = n;
		return;
	}
	if (IsFull() ){
		return;
	}
	//队列不满：1.front前有空间；2.tail后有空间
	tail = (tail + 1) % Length;
	//tail += 1;
	queue[tail] = n;
}
//删除队头数据（链表头）
void Dequeue() {
	if (IsEmpty()) {
		return;
	}
	if (front == tail) {
		front = tail = -1;
		return;
	}
	front = front + 1;
}
//返回链表头数据（队首数据）
int Front()
{
	if (IsEmpty()) {
		return -1;
	}
	else {
		return queue[front];
	}
}
//判断队列是否为空；
bool IsEmpty()
{
	if (front == -1 && tail == -1) {
		return true;
	}
	return false;
}

bool IsFull() {
	//这里front == 0，是为了保证充分利用空间，可以通过循环队列去添加元素；

	/*作为简单队列时的判满条件；
	if (tail % Length == 0&&front == 0 &&tail!=front) {
		return true;
	}
	else {
		return false;
	}*/

	//作为循环队列时的判满条件；
		if ((tail + 1) % Length == front) {
			return true;
		}
		else {
			return false;
		}
}

void printqueue() {
	for (int i = front; i <= tail; i++) {
		printf("%d ", queue[i]);
	}
	puts("");
	return;
}

int main() {
	Enqueue(1);
	printqueue();
	printf("队列头：%d\n", Front());
	Enqueue(2);
	printqueue();
	Enqueue(3);
	printqueue();
	printf("队列头：%d\n", Front());             
	Enqueue(4);
	printqueue();
	Enqueue(5);
	printqueue();
	Dequeue();
	printqueue();
	Dequeue();
	printqueue();
	printf("队列头：%d\n", Front());

	return 0;
}

 实现细节:

1.基于数组:如果空着,就直接front = tail = 0,queue[0] = data;如果满了,就返回;如果不满,且不空,

1)Enqueue()函数:如果空着,直接front = tail = 0;如果满了,就返回;如果不满就tail+1(可循环),所以tail = (tail + 1) % Length;

2)Dequeue()函数:如果空队列,就返回;如果front == tail,前面已经判断过不等于-1,所以只有一个元素.直接front = tail = -1;如果一般情况直接front+ 1,前面的空间就先空着.

3)front()函数:如果为空,返回-1;否则返回front索引处的数据.

4)IsEmpty()函数:当前仅当front == tail == -1L时,返回true;

5)IsFull()函数:由于数组难以扩容,所以我们总是会将他设计为循环队列来节省时间和空间.因此,我们在判断队列是否满时,总会将他看作一个圆.因此,我们会检查(tail+1)%10的模是否与front相等,如果相等则满,返回true.

2.基于链表:

1)Enqueue()函数:链表尾插法.

2)Dequeue()函数:如果队列为空,直接返回;如果队列头尾指针相等(前面已经判断过两个都为NULL),那么直接头尾指针为空,直接free(temp);剩下的情况直接换头.free(temp).

3)front()函数:调用IsEmpty()函数判断队列不为空后,直接返回head->data;

4)IsEmpty()函数:当前仅当head == tail == NULL时,返回true;