【数据结构】栈和队列3——队列的表示和实现

---

队列的抽象数据类型定义

ADT Queue{
	数据对象：D={ai|ai∈ElemSet,i=1,2,…,n,n≥0}
	数据关系：R1={<ai-1,ai>|ai-1,ai∈D,i=2,…,n}
			约定a1端为队列头，an端为队列尾
	基本操作：
		InitQueue(&Q)  操作结果：构造空队列Q
		DestroyQueue(&Q)  条件：队列Q已存在  操作结果：队列Q被销毁
		ClearQueue(&Q)  条件：队列Q已存在  操作结果：将Q清空
		QueueLength(Q)  条件：队列Q已存在  操作结果：返回Q的元素个数，即队长
		GetHead(Q,&e)  条件：Q为非空队列  操作结果：用e返回Q的队头元素
		EnQueue(&Q,e)  条件：队列Q已存在  操作结果：插入元素e为Q的队尾元素
		DeQueue(&Q,&e)  条件：队列Q已存在  操作结果：删除Q的队头元素，用e返回
		……还有将队列置空、遍历队列等操作……
}ADT Queue

队列的表示和实现

队列的物理存储可以用顺序存储结构，也可用链式存储结构。相应地，队列的存储方式也分为两种，即顺序队列和链式队列。

顺序队列

顺序队列的表示

队列的顺序表示——用一维数组base[MAXQSIZE]

#define MAXSIZE 100//最大队列长度
Typedef struct{
	QElemType *base;//初始化的动态分配存储空间
	int front;//头指针
	int rear;//尾指针
}

顺序队列的实现

溢出问题：

解决假上溢的方法：
1、将队中元素依次向队头方向移动。
缺点：浪费时间，每移动一次，队中元素都要移动。
2、将队空间设想成一个循环的表，即分配给队列的m个存储单元可以循环使用，当rear为maxqsize时，若向量的开始端空着，又可从头使用空着的空间。当front为maxqsize时，也是一样。——引入循环队列

循环队列

循环队列的表示

• 描述：base[0]接在base[MAXQSIZE -1]之后，若rear+1==M，则令rear=0；
• 实现方法：利用模(mod, C语言中: %)运算。
• 插入元素:

Q.base[Q.rear]=x;
Q.rear=(Q.rear+1)%MAXQSIZE;

• 删除元素:

x=Q.base[s.front];
Q.front=(Q.front+1)%MAXQSIZE;

• 队空队满的区分
  
  解决方案：
  ① 另外设一个标志以区别队空、队满；
  ② 另设一个变量，记录元素个数；
  ③ 少用一个元素空间。（常用）
  

循环队列的实现

循环队列的类型定义

#define MAXSIZE 100//最大队列长度
Typedef struct{
	QElemType *base;//动态分配存储空间
	int front;//头指针，若队列不空，指向队列头元素
	int rear;//尾指针，若队列不空，指向队列尾元素的下一个位置
}SqQueue;//定义的结构是普通类型，没有*不是指针类型，普通类型引用成员用“.”,指针类型引用成员用“->”。

1、队列的初始化

Status InitQueue(SqQueue &Q){
	Q.base=new QElemType[MAXQSIZE]//分配数组空间
	//同 Q.base=(QElemType*)malloc(Maxsize*sizeof(QElemType));
	if(!Q.base)
		exit(OVERFLOW);//存储分配失败
	Q.front=Q.rear=0;//头指针尾指针置为0，队列为空
	return OK;
}

2、求队列的长度

int QueueLength(SqQueue Q){
	return((Q.rear-Q.front+MAXQSIZE)%MAXQSIZE);
}

3、循环队列的入队

Status EnQueue(SqQueue &Q,QElemType e){
	if((Q.rear+1)%MAXQSIZE==Q.front)//队满
		return error;
	Q.base[Q.rear]=e;//新元素加入队尾
	Q.rear=(Q.rear+1)%MAXQSIZE;//队尾指针+1,取模可以避免负数出现
	return ok;
}

4、循环队列的出队

Status DeQueue(SqQueue &Q,QElemType &e){
	if(Q.front==Q.rear)//队空
		return error;
	e=Q.base[Q.front];//保存队头元素
	Q.front=(Q.front+1)%MAXQSIZE;//队头指针+1
	return OK;
}

5、取队头元素

SElemType GetHead(SqQueue Q){
	if(Q.front!=Q.rear)//队列不为空
		return Q.base[Q.front];//返回队头指针元素的值，队头指针不变
}

链队列

若用户无法估计所用队列的长度，则宜采用链队列。

链队列的表示

• 链队列的类型定义

#define MAXSIZE100//最大队列长度
typedef struct Qnode{
	QElemType data;
	struct Qnode *next;
}QNode,*QueuePtr;
typedef struct{
	QueuePtr front;//队头指针
	QueuePtr rear;//队尾指针
}LinkQueue;

• 链队列运算指针变化状况

链队列的实现

1、链队列的初始化

Status InitQueue(LinkQueue &Q){
	Q.front=Q.rear=(QueuePtr)malloc(ziseof(QNode));
	if(!Q.front)
		exit(OVERFLOW);
	Q.front->next=NULL;
	return OK;
}

2、链队列的销毁
【算法思想】从队头结点开始，依次释放所有结点

Status DestroyQueue(LinkQueue &Q){
	while(Q.front){
		p=Q.front->next;
		free(Q.front);
		Q.front=p;
	}
	return OK;
}

3、链队列的入队

Status EnQueue(LinkQueeu &Q,QElemType e){
	p=(QueuePtr)malloc(sizeof(QNode));
	if(!p)
		exit(OVERFLOW);
	p->data=e;
	p->next=NULL;
	Q.rear->next=p;
	Q.rear=p;
	return OK;
}

4、链队列的出队

Status DeQueue(LinkQueue &Q,QElemType &e){
	if(Q.front==Q.rear)
		return error;
	p=Q.front->next;
	e=p->data;
	Q.front->next=p->next;
	if(Q.rear==p)//如果删除的结点是尾结点
		Q.rear=Q.front;
	delete p;
	return OK;
}

5、求链队的队头元素

Status GetHead(LinkQueue Q,QElemType &e){
	if(Q.front==Q.rear)
		return error;
	e=Q.front->next->data;
	return ok;
}

---