队列的实现（顺序表和链表）

目录

• 一、队列的概念
• 二、入队
• 三、出队
• 四、出队

一、队列的概念

队列是仅限于在表尾进行插入，表头进行删除元素的线性表，遵循先进先出，就像排队一样。

队列常用于实现排队系统，任务调度，消息传递，我们一般可以用 顺序表 或者 链表来实现队列

二、入队

1.入队的概念

队列的插入叫做入队，它是将数据元素进行插入的过程

2.入队的步骤

第一步，将元素添加到队列的尾部，更新队尾指针或者索引

第二部，队列大小加一

三、出队

1.出队的概念

队列的删除叫做出队，他将队首元素进行删除的过程。

2.出队的步骤

第一步，删除队首元素，更新队首指针或者索引。

第二部，队列的大小减一

四、获取队首元素

1.获取队首元素的概念

返回队首指针指向元素的值，无论是链表还是顺序表，都可以通过队首指针或者索引在o(1)的时间复杂度获取到队首元素。

2.获取队首元素的步骤

第一步，利用队首指针或者索引获取队首元素返回。查询不会影响队列大小。

五、代码实现

1.顺序表实现

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

#define eleType int

// 定义一个结构体队列
typedef struct {
    eleType* elements; // 队列列表
    size_t front;      // 首元素索引
    size_t rear;       // 尾元素索引
    size_t capacity;   // 队列容量
}Queue;

// 队列初始化
void Queuecreat(Queue* q){
    q->elements = (eleType*)malloc(sizeof(eleType) * 8);    // 分配八个eleType大小元素空间
    q->front = 0;                                           // 首元素索引为0
    q->rear = 0;                                            // 尾元素索引为0
    q->capacity = 8;                                        // 容量初始化为8
}

// 队列的销毁
void Queuedestroy(Queue* q){
    free(q->elements);                                      // 释放空间
    q->front = 0;                                           
    q->rear = 0;
    q->capacity = 0;
    q->elements = NULL;
}

// 队列的扩容
void Queueresize(Queue* q){
    eleType* newq = (eleType*)realloc(q->elements,sizeof(eleType)*(q->capacity * 2)); // 重新分配空间为原来的2倍
    q->elements = newq;                                                               // 原来的更新为新的   
    q->capacity = q->capacity * 2;                                                    // 容量乘以2
}

// 入队
void Queuepush(Queue* q,eleType element){
    if(q->rear == q->capacity){                     // 如果队尾索引等于容量说明队列满了，进行扩容操作
        Queueresize(q);                                                     
    }
    q->elements[q->rear++] = element;               // 
}

// 出队
eleType Queuepop(Queue* q){
    if(q->front == q->rear){
        printf("空栈\n");
        exit(1);
    }
    return q->elements[q->front++];
}

// 获取队首元素
eleType Queuetop(Queue* q){
    if(q->front == q->rear){
        printf("空栈\n");
        exit(1);
    }
    return q->elements[q->front];
}

// 获取队列大小
size_t Queuesize(Queue* q){
    return q->rear - q->front;
}


int main(){
    Queue q;
    Queuecreat(&q);
    Queuepush(&q,100);
    Queuepush(&q,200);
    Queuepush(&q,30);
    Queuepush(&q,60);
    Queuepush(&q,50);
    Queuepush(&q,70);
    Queuepush(&q,80);
    Queuepush(&q,90);
    Queuepush(&q,100);
    printf("pop is %d\n",Queuepop(&q));
    printf("top is %d\n",Queuetop(&q));
    printf("size is %d\n",Queuesize(&q));
    Queuedestroy(&q);
    return 0;
}

加入九个元素，弹出一个没什么问题，

2.链表实现

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

#define eleType int

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

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

// 创建队列
void Queuecreat(Queue* q) {
    q->front = q->rear = NULL;
    q->size = 0;
}

// 销毁队列
void Queuedestroy(Queue* q) {
    while (q->front) {
        Node* current = q->front;
        q->front = q->front->next;
        free(current);
    }
    q->rear = NULL;
    q->size = 0;
}

// 入队
void Queuepush(Queue* q, eleType element) {
    Node* newnode = (Node*)malloc(sizeof(Node));
    newnode->data = element;
    newnode->next = NULL;
    if (q->rear == NULL) {
        q->front = q->rear = newnode;
    } else {
        q->rear->next = newnode;
        q->rear = newnode;
    }
    q->size++;
}

// 出队
eleType Queuepop(Queue* q) {
    if (q->front == NULL) {
        printf("空队列\n");
        exit(1);
    }
    eleType element = q->front->data;
    Node* temp = q->front;
    q->front = q->front->next;
    free(temp);
    q->size--;
    if (q->size == 0) {
        q->rear = NULL;
    }
    return element;
}

// 获取队首元素
eleType Queuetop(Queue* q) {
    if (q->front == NULL) {
        printf("空队列\n");
        exit(1);
    }
    return q->front->data;
}

// 获取队列大小
size_t Queuesize(Queue* q) {
    return q->size;
}

int main() {
    Queue q;
    Queuecreat(&q);
    Queuepush(&q, 10);
    Queuepush(&q, 20);
    Queuepush(&q, 30);
    printf("队首元素是 %d\n", Queuetop(&q));
    printf("出队元素是 %d\n", Queuepop(&q));
    printf("队首元素是 %d\n", Queuetop(&q));
    printf("队列大小是 %zu\n", Queuesize(&q));
    Queuedestroy(&q);
    return 0;
}

没有问题