数据结构之队列

简要描述

        队列（Queue）是一种基本的数据结构，它遵循先进先出（First In, First Out，FIFO）的原则。即，最先入队的元素将最先被移除，而最后入队的元素将在队列中等待较长的时间。队列通常用于在数据集合中进行顺序处理。

 

主要特点

1. 先进先出（FIFO）： 队列的主要特点是遵循先进先出的原则。在队列中，最先进入的元素将被最先移出，保持了元素的顺序。

2. 只允许在队列的一端进行操作： 队列的基本操作包括入队（Enqueue）和出队（Dequeue）。元素的插入只发生在队尾，而元素的删除只发生在队头。

3. 限制性操作： 由于队列只允许在队头和队尾进行操作，因此在中间插入或删除元素是不允许的。

4. 实现方式灵活： 队列可以通过数组或链表来实现。数组实现的队列有固定的大小，而链表实现的队列可以动态调整大小。 

 

 基本操作

        入队操作（Enqueue）

// 入队操作
void enqueue(Queue *queue, int element) {
    if (queue->rear == MAX_SIZE - 1) {
        printf("Queue is full. Cannot enqueue.\n");
        return;
    }

    if (queue->front == -1) {
        // 如果队列为空，设置队头指针
        queue->front = 0;
    }

    // 在队尾添加元素
    queue->rear++;
    queue->data[queue->rear] = element;
}

         出队操作（Dequeue）

// 出队操作
int dequeue(Queue *queue) {
    if (queue->front == -1) {
        printf("Queue is empty. Cannot dequeue.\n");
        return -1;
    }

    // 获取队头元素
    int element = queue->data[queue->front];

    // 移动队头指针
    if (queue->front == queue->rear) {
        // 如果队列中只有一个元素，出队后将队头和队尾指针重置
        queue->front = -1;
        queue->rear = -1;
    } else {
        queue->front++;
    }

    return element;
}

        查看队头元素（Front）

// 查看队头元素
int front(Queue *queue) {
    if (queue->front == -1) {
        printf("Queue is empty. No front element.\n");
        return -1;
    }

    return queue->data[queue->front];
}

        判断队列是否为空（Empty）

// 判断队列是否为空
int isEmpty(Queue *queue) {
    return (queue->front == -1);
}

队列的应用场景

1. 任务调度： 操作系统中的进程调度通常使用队列，确保按照提交任务的先后顺序进行处理。

2. 广度优先搜索（BFS）： 在图的广度优先搜索中，队列被用来管理待访问的节点。

3. 打印队列： 打印任务通常按照先后顺序排队等待执行，这可以用队列来实现。

4. 网络数据传输： 数据包通常按照先后顺序在网络中传输，队列确保数据包按照提交的顺序处理。

5. 缓冲区管理： 在计算机系统中，队列用于管理缓冲区，确保数据按照顺序传递。

队列的实现方式

1. 数组实现： 使用数组来表示队列，使用两个指针分别指向队头和队尾。在入队和出队操作中，分别移动这两个指针。

2. 链表实现： 使用链表来表示队列，每个节点包含一个数据元素和一个指向下一个节点的指针。在入队和出队操作中，调整链表的指针。

3. 循环队列： 通过数组实现，队尾和队头相连形成一个环。这样可以避免队列满时的元素搬移操作。

  

代码完整实现 

#include<stdlib.h>
#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 Empty(SqQueue Q){
	if(Q.front==Q.rear){
		return true;
	}
	return false;
} 
//入队
 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;
	  return true;
 } 
//出队
bool DeQueue(SqQueue &Q,int &e){
	//判空
	if(Q.front==Q.rear){
	  return false;
	}
	e=Q.data[Q.front];
	Q.front=(Q.front+1)%MaxSize;
	return true; 
} 
//获得队头元素
bool GetHead(SqQueue &Q,int &e){
	//判空
	if(Q.front==Q.rear){
	  return false;
	}
	e=Q.data[Q.front];
	return true;
} 
//判断队列已满
//方法一 
//(Q.rear+1)%MaxSize=Q.front;
/*方法二
 typedef struct{
	int data[MaxSize];
	int front,rear;
	int size=0; 
} SqQueue;
入队size++;
出队size--;
if(size==MaxSize)队列已满
 */
/*方法三
 typedef struct{
	int data[MaxSize];
	int front,rear;
	int tag=0; 
} SqQueue;  
入队tag=1;
出队tag=0;
判满 Q.rear==Q.front && tag==1
*/
int main(){
	
}