第三章-队

队（Queue）是一种常见的数据结构，它遵循先进先出（FIFO）的原则。队列通常用于在程序中存储和处理需要按照特定顺序排列的元素。以下是一些常见的队列类型：

1. 普通队列（Queue）：最基本的队列类型，按照先进先出的原则进行操作。
2. 优先队列（Priority Queue）：队列中的元素带有优先级，具有较高优先级的元素先出队。
3. 双端队列（Deque）：允许在队列的两端进行插入和删除操作，可以在队头和队尾同时进行入队和出队操作。
4. 阻塞队列（Blocking Queue）：在队列满或空时，对入队或出队操作进行阻塞，直到队列有空间或有新元素可用。
5. 循环队列（Circular Queue）：使用固定大小的数组实现的队列，当队尾到达数组末尾时，可以循环回到数组的开头。
6. 并发队列（Concurrent Queue）：支持在多个线程之间安全地进行并发操作的队列。

这些队列类型可以根据具体的需求和场景来选择使用。每种队列类型都有自己的特点和适用范围，可以根据问题的要求选择最合适的队列类型来实现相应的功能。

下面是使用C语言实现队列的顺序表和链表两种数据结构的基本操作代码示例：

1. 队列的顺序表实现：

```c
#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

typedef struct {
    int queue[MAX_SIZE];
    int front;
    int rear;
} Queue;

// 初始化队列
void init(Queue *q) {
    q->front = -1;
    q->rear = -1;
}

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

// 判断队列是否已满
int is_full(Queue *q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}

// 入队
void enqueue(Queue *q, int item) {
    if (is_full(q)) {
        printf("Queue overflow\n");
        return;
    }
    if (is_empty(q)) {
        q->front = 0;
        q->rear = 0;
    } else {
        q->rear = (q->rear + 1) % MAX_SIZE;
    }
    q->queue[q->rear] = item;
}

// 出队
int dequeue(Queue *q) {
    if (is_empty(q)) {
        printf("Queue underflow\n");
        return -1;
    }
    int item = q->queue[q->front];
    if (q->front == q->rear) {
        q->front = -1;
        q->rear = -1;
    } else {
        q->front = (q->front + 1) % MAX_SIZE;
    }
    return item;
}

// 获取队头元素
int front(Queue *q) {
    if (is_empty(q)) {
        printf("Queue is empty\n");
        return -1;
    }
    return q->queue[q->front];
}

// 获取队列大小
int size(Queue *q) {
    if (is_empty(q)) {
        return 0;
    }
    return (q->rear - q->front + MAX_SIZE) % MAX_SIZE + 1;
}
```

2. 队列的链表实现：

```c
#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node *next;
} Node;

typedef struct {
    Node *front;
    Node *rear;
} Queue;

// 初始化队列
void init(Queue *q) {
    q->front = NULL;
    q->rear = NULL;
}

// 判断队列是否为空
int is_empty(Queue *q) {
    return q->front == NULL;
}

// 入队
void enqueue(Queue *q, int item) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("Memory allocation failed\n");
        return;
    }
    newNode->data = item;
    newNode->next = NULL;
    if (is_empty(q)) {
        q->front = newNode;
        q->rear = newNode;
    } else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}

// 出队
int dequeue(Queue *q) {
    if (is_empty(q)) {
        printf("Queue underflow\n");
        return -1;
    }
    Node *temp = q->front;
    int item = temp->data;
    q->front = q->front->next;
    free(temp);
    if (q->front == NULL) {
        q->rear = NULL;
    }
    return item;
}

// 获取队头元素
int front(Queue *q) {
    if (is_empty(q)) {
        printf("Queue is empty\n");
        return -1;
    }
    return q->front->data;
}

// 获取队列大小
int size(Queue *q) {
    int count = 0;
    Node *current = q->front;
    while (current != NULL) {
        count++;
        current = current->next;
    }
    return count;
}
```

上述代码实现了队列的基本操作，包括：
- `init`: 初始化队列。
- `is_empty`: 判断队列是否为空，返回整数值。
- `enqueue`: 将元素入队。
- `dequeue`: 将元素出队，并返回该元素。
- `front`: 返回队头元素，但不出队。
- `size`: 返回队列的大小。

队列的顺序表实现使用数组来存储队列元素，使用`front`和`rear`两个指针分别指向队头和队尾。队列的链表实现使用链表来存储队列元素，使用`front`和`rear`两个指针分别指向链表的头部和尾部。

你可以根据需要选择使用队列的顺序表实现或链表实现来适应不同的场景。

1. 队列的顺序表实现：

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

typedef struct {
    int queue[MAX_SIZE];
    int front;
    int rear;
} Queue;

// 初始化队列
void init(Queue *q) {
    q->front = -1;
    q->rear = -1;
}

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

// 判断队列是否已满
int is_full(Queue *q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}

// 入队
void enqueue(Queue *q, int item) {
    if (is_full(q)) {
        printf("Queue overflow\n");
        return;
    }
    if (is_empty(q)) {
        q->front = 0;
        q->rear = 0;
    } else {
        q->rear = (q->rear + 1) % MAX_SIZE;
    }
    q->queue[q->rear] = item;
}

// 出队
int dequeue(Queue *q) {
    if (is_empty(q)) {
        printf("Queue underflow\n");
        return -1;
    }
    int item = q->queue[q->front];
    if (q->front == q->rear) {
        q->front = -1;
        q->rear = -1;
    } else {
        q->front = (q->front + 1) % MAX_SIZE;
    }
    return item;
}

// 获取队头元素
int front(Queue *q) {
    if (is_empty(q)) {
        printf("Queue is empty\n");
        return -1;
    }
    return q->queue[q->front];
}

// 获取队列大小
int size(Queue *q) {
    if (is_empty(q)) {
        return 0;
    }
    return (q->rear - q->front + MAX_SIZE) % MAX_SIZE + 1;
}

2.队列的链表实现

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node *next;
} Node;

typedef struct {
    Node *front;
    Node *rear;
} Queue;

// 初始化队列
void init(Queue *q) {
    q->front = NULL;
    q->rear = NULL;
}

// 判断队列是否为空
int is_empty(Queue *q) {
    return q->front == NULL;
}

// 入队
void enqueue(Queue *q, int item) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("Memory allocation failed\n");
        return;
    }
    newNode->data = item;
    newNode->next = NULL;
    if (is_empty(q)) {
        q->front = newNode;
        q->rear = newNode;
    } else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}

// 出队
int dequeue(Queue *q) {
    if (is_empty(q)) {
        printf("Queue underflow\n");
        return -1;
    }
    Node *temp = q->front;
    int item = temp->data;
    q->front = q->front->next;
    free(temp);
    if (q->front == NULL) {
        q->rear = NULL;
    }
    return item;
}

// 获取队头元素
int front(Queue *q) {
    if (is_empty(q)) {
        printf("Queue is empty\n");
        return -1;
    }
    return q->front->data;
}

// 获取队列大小
int size(Queue *q) {
    int count = 0;
    Node *current = q->front;
    while (current != NULL) {
        count++;
        current = current->next;
    }
    return count;
}