队列的学习（浅）

顺序队列

顺序队列是用静态数组实现的；结构体里面有前后指针front与rear（前后索引），front用来记录出队的下标，rear用来记录入队的下标

#include<iostream>
using namespace std;
#define max 20
typedef struct myQueue
{
	int front;
	int rear;
	int data[max];
}myQueue;
myQueue* initQueue()
{
	myQueue* head = new myQueue;
	head->rear = head->front = 0;//初始化首尾索引指针
	return head;
}
bool isEmpty(myQueue* head)
{
	if (head->rear == 0)//如果队尾索引为0，则队列为空
		return 1;
	else
		return 0;
}
bool isFull(myQueue* head)
{
	if (head->rear == max)//如果队尾索引达到最大值max，则队列已满
		return 1;
	else
		return 0;
}
int enQueue(myQueue* head, int x)
{
	if (isFull(head))
		return 0;
	else
	{
		head->data[head->rear] = x;
		head->rear++;//每入队一个元素，队尾索引指向下一个位置
		return 1;
	}
}
int deQueue(myQueue* head)
{
	if (isEmpty(head))
		return 0;
	else
	{
		head->front++;//每出队一个元素，front指向下一个位置
		return 1;
	}
}
void showQueue(myQueue* head)
{
	int temp1,temp2;//为了不改变front与rear索引，设置工作索引指针来遍历队列
	temp1 = head->front;
	temp2 = head->rear;
	for ( ; temp1 < temp2; temp1++)
	{
		cout << head->data[temp1] << " ";
	}
	cout << endl;
}
int main()
{
	myQueue* head = initQueue();
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		int x;
		cin >> x;
		enQueue(head, x);
	}
	showQueue(head);
	deQueue(head);
	deQueue(head);
	showQueue(head);
}

链式队列

#include<iostream>
using namespace std;
typedef struct myQueue
{
	int data;
	struct myQueue* next;
}myQueue;
myQueue* initQueue()
{
	myQueue* head = new myQueue;
	head->next = NULL;
	return head;
}
bool isEmpty(myQueue* head)
{
	if (head->next == NULL)
		return 1;
	else
		return 0;
}
int enQueue(myQueue* head, int x)//入队操作类似链表的尾插法
{
	myQueue* node = new myQueue;
	myQueue* temp = head;
	while (temp->next != NULL)//找到最后一个结点
	{
		temp = temp->next;
	}
	node->data = x;
	node->next = temp->next;
	temp->next = node;
	return 1;
}
int deQueue(myQueue* head)//出队相当于链表的顺序删除
{
	if (isEmpty(head))
		return 0;
	else
	{
		myQueue* temp = head->next;
		head->next = temp->next;
		delete temp;
		return 1;
	}
}
void showQueue(myQueue* head)
{
	myQueue* temp = head->next;//设置工作指针来遍历队列
	while(temp!=NULL)
	{
		cout << temp->data << " ";
		temp = temp->next;
	}
	cout << endl;
}
int main()
{
	myQueue* head = initQueue();
	int n;
	cout << "请输入入队元素的个数：";
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		int x;
		cout << "请输入入队元素：";
		cin >> x;
		enQueue(head, x);
	}
	cout << "队列情况：";
	showQueue(head);
	cout << "出队一个：";
	deQueue(head);
	showQueue(head);
}

循环队列：
1、循环队列是队列的顺序存储结构
2、循环队列用判断是否为空利用 Q.front=Q.rear
3、循环队列头指针始终指向队列头元素，而尾指针始终指向队列尾元素的下一个位置
4、按照队列的定义，队头删除，队尾插入

循环队列的结点结构

front与rear为索引指针；front始终指向队列头元素，rear指向队列尾的下一个位置（相当于空）

typedef struct queue
{
	int front;
	int rear;
	int data[MAXSIZE];
}Queue;

初始队列

初始化队头指针front与rear；都赋值为0；并且返回q指针

Queue* initQueue()
{
	Queue* q = (Queue*)malloc(sizeof(Queue));
	q->front = q->rear = 0;//初始化队头，队尾
	return q;
}

判断队列满与空

队列空：q->rear==q->front

队列满：(q->rear + 1) % MAXSIZE == q->front

(q->rear + 1) % MAXSIZE == q->front来实现队列循环的下标---越界问题

//判断队列满
bool isFull(Queue* q)
{//牺牲队列中的一个位置来做如下判断
	if ((q->rear + 1) % MAXSIZE == q->front)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
//判断队列空
bool isEmpty(Queue* q)
{
	if (q->front == q->rear)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

入队

每次入队后，将队尾rear指向下一个位置，

注意越界问题----(q->rear + 1) % MAXSIZE == q->front

//入队
int enQueue(Queue* q, int x)
{
	if (isFull(q))
	{
		return 0;
	}
	else
	{
		q->data[q->rear] = x;
		q->rear = (q->rear + 1) % MAXSIZE;
		return 1;
	}
}

出队

出队后，将front指向下一个位置，

注意越界问题---q->front = (q->front + 1) % MAXSIZE

//出队
int deQueue(Queue* q)
{
	if (isEmpty(q))
	{
		return -1;
	}
	else
	{
		int x = q->data[q->front];
		q->front = (q->front + 1) % MAXSIZE;
		return x;
	}
}

遍历队列

队列的长度：队尾 - 队头 + MAXSIZE//防止出现负数的情况

再取余--不超过限制长度---( 队尾 - 队头 + MAXSIZE ) % MAXSIZE

//遍历队列
void printQueue(Queue* q)
{
	int length = (q->rear - q->front + MAXSIZE) % MAXSIZE;
	int index = q->front;//不能改变front与rear
	for (int i = 0; i < length; i++)
	{
		cout << q->data[index] << "->";
		index = (index + 1) % MAXSIZE;//遍历时一样会遇到边界
	}
	cout << "NULL" << endl;
}

完整的循环队列

#include<iostream>
#include<stdlib.h>
using namespace std;
//C语言实现
#define MAXSIZE 5
typedef struct queue
{
	int front;
	int rear;
	int data[MAXSIZE];
}Queue;
//初始化队列
Queue* initQueue()
{
	Queue* q = (Queue*)malloc(sizeof(Queue));
	q->front = q->rear = 0;//初始化队头，队尾
	return q;
}
//判断队列满
bool isFull(Queue* q)
{//牺牲队列中的一个位置来做如下判断
	if ((q->rear + 1) % MAXSIZE == q->front)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
//判断队列空
bool isEmpty(Queue* q)
{
	if (q->front == q->rear)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
//入队
int enQueue(Queue* q, int x)
{
	if (isFull(q))
	{
		return 0;
	}
	else
	{
		q->data[q->rear] = x;
		q->rear = (q->rear + 1) % MAXSIZE;
		return 1;
	}
}
//出队
int deQueue(Queue* q)
{
	if (isEmpty(q))
	{
		return -1;
	}
	else
	{
		int x = q->data[q->front];
		q->front = (q->front + 1) % MAXSIZE;
		return x;
	}
}
//遍历队列
void printQueue(Queue* q)
{
	int length = (q->rear - q->front + MAXSIZE) % MAXSIZE;
	int index = q->front;
	for (int i = 0; i < length; i++)
	{
		cout << q->data[index] << "->";
		index = (index + 1) % MAXSIZE;
	}
	cout << "NULL" << endl;
}
int main()
{
	Queue* q = initQueue();
	enQueue(q, 0);
	enQueue(q, 1);
	enQueue(q, 2);
	enQueue(q, 3);
	printQueue(q);
	deQueue(q);
	printQueue(q);
	deQueue(q);
	printQueue(q);
	return 0;
}