循环队列与链队列的入队出队及其基本操作

一，队列的定义

队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表

• 队列是一种先进先出的线性表，简称FIFO
• 允许插入的一端称为队尾
• 允许删除的一端称为队头

二，循环队列

定义

队列头尾相接的顺序存储结构称为循环队列

• 设front指针指向队头元素，rear指针指向队尾元素的下一个位置，队列为空队列时，front 等于 rear
  

• 队列满时，front == rear，为了区分队列空，有两种方法
  （1） 设置一个标志变量 flag，当 front 等于 rear 且 flag = 0 时队列为空，当 front 等于 rear 且 flag = 1 时队列为满
  （ 2）修改一下条件，当队列还有一个元素空间时，我们认为队列已满，如图所示
  
  rear 可能比 front 大，也可能比 front 小，假设队列最大长度为Qsize ，那么队列满的条件为：
  （rear + 1）% Qsize == front
  计算队列长度公式为：
  （rear - front + Qsize）% Qsize

头指针与头结点的区别

头指针	头结点
头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针	头结点是为了操作的统一和方便设立的，放在第一元素的结点之前，其数据域一般无意义（也可存放链表的长度）
头指针具有标识作用，所以常用头指针冠以链表的名字	有了头结点，对在第一元素结点前插入结点和删除第一结点，其操作与其它结点的操作就统一了
无论链表是否为空，头指针均不为空	若链表为空，则链表中没有头结点
头指针是链表的必要元素	头结点不一定是链表的必要元素

空链表：没有头结点，有头指针

循环队列的结构定义代码

定义的类型可以改变

typedef struct {
	int *base;
	int front;  //头指针 
	int rear;   //尾指针，若队列不为空，指向队列尾元素的下一个位置 
}Haha;

初始化

队列为空

Haha* Init(){
	Haha *q;
	q = new Haha;  //分配新的空间 
	q->base = new int[MAX];
	q->rear = q->front = 0;
	return q;
}  

队列长度

int Length(Haha *q){
	return (q->rear-q->front+MAX)%MAX;
}

入队列操作

int En(Haha *q, int e){
	if((q->rear+1)%MAX==q->front)  //空链表 
		return 0;
	q->base[q->rear]=e;  
	q->rear=(q->rear+1)%MAX;
	return 1; 
}

出队列操作

int De(Haha *q){
	if(q->front==q->rear)
		return 0;
	printf("%d\n",q->base[q->front]);  //输出删除的元素 
	q->front = (q->front+1)%MAX;
	return 1;
} 

整体代码如下：

#include <iostream>
#include <queue>
#include <stdlib.h>
using namespace std;
#define MAX 100 

//对结点的定义 
typedef struct {
	int *base;
	int front;  //头指针 
	int rear;   //尾指针，若队列不为空，指向队列尾元素的下一个位置 
}Haha;

//初始化一个空的循环队列 
Haha* Init(){
	Haha *q;
	q = new Haha;  //分配新的空间 
	q->base = new int[MAX];
	q->rear = q->front = 0;
	return q;
}  

//在队尾插入元素
int En(Haha *q, int e){
	if((q->rear+1)%MAX==q->front)  //空链表 
		return 0;
	q->base[q->rear]=e;  
	q->rear=(q->rear+1)%MAX;
	return 1; 
}

//删除操作
int De(Haha *q){
	if(q->front==q->rear)
		return 0;
	printf("%d\n",q->base[q->front]);  //输出删除的元素 
	q->front = (q->front+1)%MAX;
	return 1;
} 

//获取队列长度
int Length(Haha *q){
	return (q->rear-q->front+MAX)%MAX;
}

//主函数
int main(){
	Haha *Q;
	Q=(Haha*)malloc(sizeof(Haha));
	Q=Init();
	for(int i = 1; i < 5; i++){
		En(Q,i);
	} 
	cout << Length(Q) << endl;
	De(Q);
	cout << Length(Q) << endl;
	return 0; 
} 

运行结果：

三，链队列

我们把队列的链式存储结构称为链队列

• 队头指针指向链队列的头结点
• 队尾指针指向终端结点
  
• 空队列时，front 和 rear 都指向头结点

一般操作如下

#include<iostream>
#include<stdLib.h>
using namespace std;

//定义链表
typedef struct Haha{
	char data;
	struct Haha *next;	
}Haha, *que;

typedef struct{
	que front;
	que rear;
}link;

//对链表初始化
void Init(link *q){
	q->front = q->rear = (que)malloc(sizeof(Haha));
	if(!(q->front)) 
		exit(1);
	q->front->next = 0;
} 

//插入新元素
void En(link *q, char e){
	que p;
	p = (que)malloc(sizeof(Haha));
	if(!p)    exit(1);
	p->data = e;
	p->next = 0;
	q->rear->next = p;
	q->rear = p;
}

//删除对头元素
int de(link *q){
	Haha *p;
	char e;
	if(q->front==q->rear)  return -1;
	p = q->front->next;
	e=p->data;
	q->front->next = p->next;
	if(q->rear == p)
		q->rear = q->front;
	free(p);
	cout << e << endl; 
	return 0;
}

//判断队列是否为空
int quee(link *q){
	if(q->front==q->rear)
		cout << "队列为空" << endl;
	else 
		cout << "队列不为空" << endl; 
}

//输出队列元素
void out(link *q){
	Haha *r=q->front->next;
	while(r){
		cout << r->data;
		r = r->next;
	} 
	cout << endl;
} 

//求队列长度
void len(link *q){
	Haha *r=q->front->next;
	int s = 0;
	while(r){
		r=r->next;
		s++;
	} 
	cout << s << endl;
} 

//销毁队列
void destroy(link *q){
	if(!q){
		cout << "链队列为空" << endl;
		exit(1); 
	}
	while(q->front){
		q->rear=q->front->next;
		free(q->front);
		q->front = q->rear;
		if(!q->rear) 
			free(q->rear);
	}
	free(q->front);
} 

int main(){
	link Q;
	Init(&Q);
	En(&Q,'a');En(&Q, 'b');En(&Q, 'c');
	out(&Q);
	len(&Q);
	de(&Q);
	out(&Q);
	quee(&Q);
	len(&Q);
	destroy(&Q);
}

运行结果如下：

这些是最基础的代码，应用时应适当改变一下操作