面试复习——数据结构（四）：队列

队列

队列的基本概念

队列(Queue) 也是运算受限的线性表

• 只允许在表的一端进行插入，而在另一端进行删除→先进先出(First In First Out ，FIFO)，先进入队列的成员总是先离开队列
• 队头(front) ：允许进行删除的一端
• 队尾(rear) ：允许进行插入的一端
• 空队列：队列中没有元素
  

队列的设计

定义：

• 队头(front)：不存数据，只是指向队列队头
• 队尾(rear)
  

操作：

• 创建一个空队列
• 销毁已存在的队列
• 将队列清为空队列
• 判断是否为空队列
• 返回队列的长度
• 返回队列的队头元素
• 向队列的队尾插入元素e
• 删除队头元素，并返回其值
• 从队头到队尾依次对队列的每个数据元素调用函数visit()

队列的具体实现

链式表示

链队列：用链表表示的队列

• 数据元素结点，设有头结点
• 队列的队头指针和队尾指针

typedef struct Node {
	ElemType data;
	struct Node *next;
}QNode;
typedef struct {
	QNode *front;
	QNode *rear;
}LinkedQueue;

// 1. 链队列的初始化，构造一个空队列
bool InitQueue(LinkedQueue *lq){
	lq->front=lq->rear=(QNode *)malloc(sizeof(QNode));
	if(!lq->front) return false;
	lq->front->next=NULL;
	return true;
}

// 2. 取队列的长度
int GetLen(LinkedQueue *lq){
	int count=0;
	QNode *p;
	if(IsQueueEmpty(lq)==0){
		p=lq->front->next;
		while(p!=lq->rear){
			count++;
			p=p->next;
		}
		count++;
	}
	return count;
}

// 3. 判断队列是否为空
int IsQueueEmpty(LinkedQueue *lq){
	if(lq->front == lq->rear) return 1;
	else return 0;
}

// 4. 查看队头元素
bool GetFront(LinkedQueue *lq,ElemType *e){
	if(lq->front == lq->rear)  return false;
	*e=lq->front->next->data;
	return ture; 
}
// 5. 元素入队(尾)
bool Enqueue(LinkedQueue *lq,ElemType e){
	QNode *p;
	p=(QNode *)malloc(sizeof(QNode));
	if(!p) return false;
	p->data =e; p->next=NULL;
	lq->rear->next=p; //修改尾指针
	lq->rear=p;
	return true;
}
//6. (队头)元素出队
bool Dequeue(LinkedQueue *lq,ElemType *e){
	QNode *p;
	if (lq->front == lq->rear) return false; 
			    	       //空队列的话，则出错
	p = lq->front->next;  //p指向第一个结点
	*e = p->data;
	lq->front->next =p->next; //修改头结点的指针
	if(lq->rear==p) //删仅有的一个元素时，需修改尾指针
		lq->rear=lq->front; 
	free(p);
	return true;
}

顺序表示

顺序队列：利用一组连续的存储单元(一维数组) 依次存放从队头到队尾的各个元素
在非空队列里，队头指针始终指向队头元素，而队尾指针始终指向队尾元素的下一位置

• 初始化：front=rear=0
• 判队列为空：front==rear
• 判队列满：rear==MAXQUEUESIZE
• 入队：将新元素插入rear所指的位置，然后rear加1
• 出队：删去front所指的元素，然后front加1并返回被删元素

#define MAXQUEUESIZE   100
typedef  struct  queue {
	ElemType  Queue_array[MAXQUEUESIZE] ;
	int  front; // 队头指针
	int  rear;  // 队尾指针
	int  queueSize;     //队列空间的大小
}SqQueue;

PS：存在假溢出问题！
在入队和出队操作中，头、尾指针只增加不减小，致使被删除元素的空间永远无法重新利用

循环队列

循环队列：将为队列分配的向量空间看成为一个首尾相接的圆环

• 在循环队列中进行出队、入队操作时，队头、队尾指针仍要加1
• 但当队头、队尾指针到达MAXQUEUESIZE-1时，其加1操作的结果是指向0
• 进队：在队尾加元素，然后rear = (rear+1) % MAXQUEUESIZE
• 出队：取队头元素，然后front = (front+1) % MAXQUEUESIZE
• 判断队空的条件(rear+1) % MAXQUEUESIZE == front（少用一个元素空间，让rear所指的单元始终为空。约定：以“队列头指针在队尾指针的下一个位置上”为队满的标志）←这只是一种判断队列满的方法，也可以增加队列计数器或标志位

#define MAXQUEUESIZE   100
typedef  struct  queue {
	ElemType *base;  // 动态分配的存储空间
	int  front; // 队头指针，若队列不空，指向队头元素
	int  rear;  // 队尾指针，若队列不空，指向队列尾元素的下一个位置
} CircularQueue;

// 队列初始化，构造一个空循环队列 
bool InitQueue(CircularQueue *cq){
	cq->base = (ElemType *)malloc 			(MAXQUEUESIZE*sizeof(ElemType));
	if(!cq->base) return false;
	cq->front=0;cq->rear=0;
	return true;
}

// 返回队列的元素个数，即队列的长度
int GetLen(CircularQueue *cq) {
	return ((cq->rear - cq->front + MAXQUEUESIZE)%MAXQUEUESIZE);
}

// 插入元素e为Q的新的队尾元素
bool Enqueue(CircularQueue *cq,ElemType e) {
	if((cq->rear+1)%MAXQUEUESIZE == cq->front)
		return false; //队列满
	cq->base[cq->rear]=e;
	cq->rear=(cq->rear+1) % MAXQUEUESIZE;
	return true;
}

// 若队列不空，则删除Q的队头元素，
// 用e返回其值，并返回true;  否则返回false
bool Dequeue(CircularQueue *cq,ElemType *e) {
	if(cq->front == cq->rear) return false;
	*e=cq->base[cq->front];
	cq->front=(cq->front +1) % MAXQUEUESIZE;
	return true;
}

队列的应用举例

杨辉三角/二项式系数生成

杨辉三角：$C(n,i)=C(n-1,i-1)+C(n-1,i)$
=> $NextRo{w}_i=CurRo{w}_{i-1}+CurRo{w}_i$
想法：用变量存$CurRo{w}_{i-1}$，队头为$CurRo{w}_i$

int main(){
	//生成总共total_row行的杨辉三角值
	CircularQueue q; ElemType e; 
	int r,total_row, cur_row_i_1=0, cur_row_i=0,next_row_i;
	InitQueue(&q); Enqueue(&q,1); Enqueue(&q,1);
	for(r=1; r<total_row;r++){
		Enqueue(&q, 0);
		//用0来作为行的分隔
		for(int c=1;c<=r+2;c++) {
			Dequeue(&q,&e);
			cur_row_i = e;
			if (e) printf("%d ", cur_row_i);
			next_row_i = cur_row_i + cur_row_i_1;
			Enqueue(&q,next_row_i);
			cur_row_i_1=cur_row_i;
		}
		printf("\n");
	}
	return 0;
}

迷宫寻路-搜索问题，寻找从入口到出口的最短路径

题目见这篇文章中的迷宫问题：https://blog.csdn.net/weixin_45770491/article/details/125271327?spm=1001.2014.3001.5501

寻找从入口到出口的最短路径，修改栈版迷宫算法，利用队列针对迷宫进行广度优先搜索
迷宫：用2维数组表示
有待搜索的通道块：用队列表示
轨迹(搜索过的块)：trajectories

起始方块入队列Q；
while (队列Q非空) {
	取Q的队头e；
	若e是终点，则 {
		从轨迹中回溯路径，
		打印路径，
		返回True
	}
	否则，将该方块记录到轨迹；
	依次取e的下一步可以走到的方块s；
	如果s是可通的方块 ，则 {
		则在该方块中记录该方块的前一个位置，
		将该方块入队，
		将该点设置为走过// FootPrint(s)；
	}
}
返回False
/********************************************/
typedef struct Node {
    ElemType data;
    struct Node *next;
}QNode;

typedef struct {
    QNode *front;
    QNode *rear;
}LinkedQueue;
char maze[10][10];
//迷宫的墙：X；
//没有走过的通道块：空格；
//走过标记：*；路径：+
typedef struct{ //迷宫的坐标
    int r,c; //r 表示行，c表示列
} PosType;

//表示路径中的一通道块
typedef struct{  
	PosType seat;
    //通道块在迷宫中的坐标位置
    PosType former;      //从哪个块走过来的
    int di; //从此通道块走向下一个通道块的方向
} ElemType;
ElemType trajectories[1000]; 
int traP=0; 

运动会日程安排

即——子集划分问题：将n个元素组成的集合A划分成k个互不相交的子集A1，A2，…，Ak (k≤n)，使同一子集中的元素均无冲突关系
有同一运动员参加的项目抽象为**“冲突”关系**
项目之间的冲突关系为:
R = {（1，4）,（4，8）,（1，8）,（1，7）,（8，3）,（1，0）,（0，5）,（1，5）,（3，4）,（5，6）,（5，2）,（6，2）,（6，4）}
数据结构：

• 设集合共有n个元素
• 用队列sq存放集合元素
• 用矩阵conflictMatrix[n][n]表示元素之间的冲突关系：
  conflictMatrix[i][j]=1, 如果i,j有冲突
  conflictMatrix[i][j]=0, 如果i,j无冲突
• 用数组result[n]存放每个元素的子集/分组编号
• 用工作数组clash[n]记录与第k组已入组元素有冲突的元素情况(当组号为k时)
  -每次新开辟一组时，令clash数组各分量的值均为0，当序号为 head 的元素入组时，将和该元素发生冲突的信息记入clash 数组
  -clash的引入可以减少重复察看conflictMatrix数组的时间

算法思想：
利用循环筛选
从第一个元素开始，无冲突的元素划归为一个子集；
再将剩下的元素重新找出互不冲突的元素，划归第二个子集
依次类推，直到所有元素都进入某个子集为止

初始化队列；全体集合元素入队列；
取队头元素，组号为1，clash的值被设置为队头元素在矩阵中的行值；
While(队列不空) {
  取队头元素x；
  若它与当前组的元素没有冲突，即Clash[x]==0 {
      在result中设置该元素对应的分组号；
      修改clash记录 (即，在原clash记录之上叠加上该元素的
      冲突情况)
      }
  否则，将x再次入队
  判断是否走完一轮 (即，若当前队列的队头的值小于前次
  取的队头的值，那么 走完一轮)
  若走完一轮，则：
	  取队头元素x，组号加1，数组clash初始化为全0
}

演示：