数据结构之队列（顺序存储+链式存储）

数据结构之队列（顺序存储+链式存储）

顺序存储

#include<stdio.h>
#define MaxSize 10
typedef struct{
	int data[MaxSize];
	int front,rear;
} SqQueue; 

//初始化队列
void InitQueue(SqQueue &Q){
	//初始化时，队头、队尾指针指向0
	Q.rear=Q.front=0; 
} 

//入队
bool EnQueue(SqQueue &Q,int x){
	if((Q.rear+1)%MaxSize==Q.front)
		return false;//队列满了
	Q.data[Q.rear]=x;//将新元素插入队尾 
	Q.rear=(Q.rear+1)%MaxSize;//插入后将队尾指针加1取模 
	return true;
}

 
//出队 
bool DeQueue(SqQueue &Q,int x){
	if(Q.rear==Q.front)
		return false;//队列为空不满足！ 
	x=Q.data[Q.front];
	Q.front=(Q.front+1)%MaxSize;//队头指针后移 
	return true;
}

//队列判空 
bool QueueEmpty(SqQueue Q){
	if(Q.rear==Q.front)
		return true;
	return false;
} 
// 读取队首元素 
bool GetTop(SqQueue Q,int &x){
	if(Q.rear==Q.front)
		return false;//队列为空不满足！ 
	x=Q.data[Q.front];
	return true;
} 
int main(){
	
}

链式存储(无头结点)

#include<stdio.h>
#include<stdlib.h>
typedef struct LinkNode {
	int data;
	struct LinkNode *next;
} LinkNode;

typedef struct {
	LinkNode *front,*rear;
} LinkQueue;

//初始化队列
void InitQueue(LinkQueue &Q){
	Q.front=NULL;
	Q.rear=NULL;
} 

//判断队列是否为空
bool IsEmpty(LinkQueue Q){
	if(Q.front==NULL)
		return true;
	return false;
} 
//入队
void EnQueue(LinkQueue &Q,int x){
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
	s->data=x;
	s->next=NULL;
	if(Q.front==NULL){
		Q.front = s;
		Q.rear=s;
	}else{
		Q.rear->next=s;
		Q.rear=s;
	}
} 

//出队
bool DeQueue(LinkQueue &Q,int &x){
	if(Q.front==NULL)
		return false;
	LinkNode *p=Q.front;
	x=p->data;
	Q.front=p->next;
	if(Q.rear==p){
		Q.front=NULL;
		Q.rear=NULL;
	}
	free(p);
	return true;
} 

int main(){
	
} 

链式存储(有头结点)

#include<stdio.h>
#include<stdlib.h>
typedef struct LinkNode {
	int data;
	struct LinkNode *next;
} LinkNode;

typedef struct {
	LinkNode *front,*rear;
} LinkQueue;

//初始化
void InitQueue(LinkQueue &Q) {
	//初始化时，front和rear都指向头指针
	Q.front =Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
	Q.front->next=NULL;
}

//入队
void EnQueue(LinkQueue &Q,int x) {
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
	s->data=x;
	s->next=NULL;
	Q.rear->next=s;//将新节点插入到rear之后
	Q.rear=s;//修改表尾指针
}
//出队
bool DeQueue(LinkQueue &Q,int &x) {
	if(Q.front=Q.rear)
		return false;//空
	LinkNode *p=Q.front->next;
	x=p->data;//用变量x返回队头元素
	Q.front->next=p->next; //修改头结点的next指针
	if(p->next==Q.rear)//如果是最后一个元素的话
		Q.rear=Q.front;
	free(p);//释放节点p的空间
	return true;
}
int main() {
}

常见问题

队空与队满

• 最基本的顺序存储方式:只能表头前出队，只能表头后进队
  队空条件：

Q.front==Q.rear==0

入队操作：队不满，先送值到队尾元素，再将队尾指针+1。
出队操作：队不空时，先取头元素值，再将队头值+1。
队满条件：
Q.rear==Maxsize
是不能解决问题的。因为在某种情况下，前面的元素都出队了，但Q.rear==Maxsize且整个队列还有空闲空间，这不能说明队满，这并不是真正的队列溢出。这种情况被称为“假溢出”。为了解决这个问题，可以考虑将该队列模式首尾相接，改为一个循环队列来解决此问题。

• 循环队列
  我们可以将存储队列的表从逻辑上视为一个环，这样的队列就成为循环队列。
  初始时：Q.front=Q.rear=0。
  队首指针进1：Q.front=(Q.front+1)%Maxsize
  队尾指针进1：Q.rear=(Q.rear+1)%Maxsize
  此时:
  队满条件

(Q.rear+1) % MaxSize == front

队空条件

Q.front==Q.rear

队列中元素的个数

(Q.rear-Q.front+MaxSize)% MaxSize