数据结构——顺序队（循环队列，链队）

顺序队

一、循环队列

1.循环队列
在顺序队中,通常让队尾指针rear指向刚进队的元素位置,让队首指针front指向刚出队的元素位置。因此，元素进队的时候，rear 要向后移动;元素出队的时候，front 也要向后移动。这样经过一系列的出队和进队操作以后，两个指针最终会达到数组末端maxSize-1处。虽然队中已经没有元素，但仍然无法让元素进队，这就是所谓的“假溢出”。要解决这个问题，可以把数组弄成一个环，让rear和front沿着环走，这样就永远不会出现两者来到数组尽头无法继续往下走的情况，这样就产生了循环队列。循环队列是改进的顺序队列。

2.循环队列的要素
（1）两个状态
①队空状态qu.rear==qu.front.

②队满状态（qu.rear+1)%maxSize==qu.front.

（2）两个操作
①元素x进队操作（移动队尾指针）

qu.rear=(qu.rear+1)%maxSize;qu.data[qu.rear]=x;

②元素x出队操作（移动队首指针）

qu.front=(qu.front+1%maxSize;x=qu.data[qu.front]

3.初始化队列算法

//初始化队列算法 
void initQueue(SqQueue &qu){
	qu.front=qu.rear=0;
}

4.判断队空算法

//判断队空算法
int isQueueEmpty(SqQueue qu){
	if(qu.front==qu.rear) return 1;
	else return 0;
} 

5.进队算法

//进队算法
int enQueue(SqQueue &qu,int x){
	if((qu.rear+1)%maxSize==qu.front)return 0;
	qu.rear=(qu.rear+1)%maxSize;
	qu.data[qu.rear]=x;
	return 1;
} 

6.出队算法

//出队算法
int deQueue(SqQueue &qu,int &x){
	if(qu.front==qu.rear)return 0;
	qu.front=(qu.front+1)%maxSize;
	x=qu.data[qu.front];
	return 1;
} 

二、链队

链队就是采用链式存储结构存储队列，这里采用单链表来实现。链队的特点就是不存在队列满上溢的情况
1.链队的要素
链队有两个特殊状态和两个操作
（1）两个状态
①队空状态

lqu->rear=NULL或者lqu->front==NULL

②队满状态
不存在队满的情况（假设内存无限大的情况下不存在）
（2）两个操作
①元素进队操作（假设p指向进队元素）

lqu->rear->next=p;lqu->rear=p;

②元素出队操作（假设x存储出队元素）

p=lqu->front;lqu->front=p->next;x=p->data;free(p);

2.初始化链队算法

//初始化链队算法 
void initQueue(LiQueue &lqu){
	lqu=(LiQueue*)malloc(sizeof(LiQueue));
	lqu->front=lqu->rear=NULL;
}

3.判断队空算法

//判断队空算法
int isQueueEmpty(LiQueue *lqu){
	if(qu->front==NULL||qu->rear==NULL) return 1;
	else return 0;
} 

4.进队算法

//进队算法
int enQueue(LiQueue &lqu,int x){
	QNode *p;
	p=(QNode*)malloc(sizeof(QNode));
	p->data=x;
	p->next=NULL;
	if(lqu->rear==NULL)lqu->front=qu->rear=p;
	else{
		lqu->rear->next=p;
		lqu->rear=p;
	}
} 

5.出队算法

//出队算法
int deQueue(SqQueue &qu,int &x){
	QNode *p;
	if(lqu->rear==NULL)return 0;
	else p=lqu->front;
	if(lqu->front==lqu->rear)//队列中只有一个结点时候出队操作需要特殊处理 
	lqu->front=lqu->rear=NULL;
	else
	lqu->front=lqu->front->next;
	x=p->data;
	free(p);
	return 1; 
}