1. PingCode智库首页
  2. 百科

c语言如何写队列

Edit1 • • 百科

c语言如何写队列

在C语言中如何写队列：定义数据结构、初始化队列、入队操作、出队操作

在C语言中，编写一个队列需要从定义数据结构、初始化队列、入队操作、出队操作等几个核心步骤来实现。队列是一种先进先出（FIFO，First In First Out）的数据结构，因此需要特别注意保持元素的顺序。以下是详细描述如何在C语言中实现队列的具体步骤。

一、定义数据结构

在C语言中，队列通常使用结构体来定义。一个基本的队列结构需要包含数组（或链表）来存储数据，以及指示队列头和尾的指针或索引。

typedef struct {


    int *array;  // 用来存储队列元素的数组


    int capacity;  // 队列的最大容量


    int size;  // 队列当前的大小


    int front;  // 队列头部的索引


    int rear;  // 队列尾部的索引


} Queue;

二、初始化队列

初始化队列时，需要动态分配数组的内存，并设置初始值。以下是一个初始化队列的示例函数：

#include <stdlib.h>


#include <stdio.h>


// 初始化队列


Queue* createQueue(int capacity) {


    Queue *queue = (Queue *)malloc(sizeof(Queue));


    queue->capacity = capacity;


    queue->array = (int *)malloc(queue->capacity * sizeof(int));


    queue->size = 0;


    queue->front = 0;


    queue->rear = -1;


    return queue;


}

三、入队操作

入队操作是将一个新元素添加到队列的尾部。需要检查队列是否已满，并更新队列的尾部索引和大小。

// 入队操作


void enqueue(Queue *queue, int item) {


    if (queue->size == queue->capacity) {


        printf("Queue is full!n");


        return;


    }


    queue->rear = (queue->rear + 1) % queue->capacity;


    queue->array[queue->rear] = item;


    queue->size++;


    printf("%d enqueued to queuen", item);


}

四、出队操作

出队操作是从队列的头部移除一个元素。需要检查队列是否为空，并更新队列的头部索引和大小。

// 出队操作


int dequeue(Queue *queue) {


    if (queue->size == 0) {


        printf("Queue is empty!n");


        return -1;


    }


    int item = queue->array[queue->front];


    queue->front = (queue->front + 1) % queue->capacity;


    queue->size--;


    return item;


}

五、检查队列状态

为了更好地操作队列，我们还可以实现一些辅助函数，比如检查队列是否为空或已满。

// 检查队列是否为空


int isEmpty(Queue *queue) {


    return (queue->size == 0);


}


// 检查队列是否已满


int isFull(Queue *queue) {


    return (queue->size == queue->capacity);


}


// 获取队列头部元素


int front(Queue *queue) {


    if (isEmpty(queue)) {


        printf("Queue is empty!n");


        return -1;


    }


    return queue->array[queue->front];


}


// 获取队列尾部元素


int rear(Queue *queue) {


    if (isEmpty(queue)) {


        printf("Queue is empty!n");


        return -1;


    }


    return queue->array[queue->rear];


}

六、队列的应用场景

队列在计算机科学和工程中有着广泛的应用，以下是几个典型的应用场景：

  • 操作系统中的任务调度：操作系统使用队列来管理任务的执行顺序，例如进程调度和打印任务管理。
  • 广度优先搜索（BFS）：在图的遍历中，广度优先搜索算法利用队列来记录待访问的节点。
  • 资源管理：例如在网络服务器中，使用队列来管理请求的处理顺序。

七、链式队列的实现

除了使用数组实现队列外，链表也是一种常见的实现方式。链式队列不需要预设容量限制，适合内存动态分配的场景。

链式队列的数据结构

typedef struct QueueNode {


    int data;


    struct QueueNode *next;


} QueueNode;


typedef struct {


    QueueNode *front;


    QueueNode *rear;


    int size;


} LinkedQueue;

链式队列的初始化

LinkedQueue* createLinkedQueue() {


    LinkedQueue *queue = (LinkedQueue *)malloc(sizeof(LinkedQueue));


    queue->front = queue->rear = NULL;


    queue->size = 0;


    return queue;


}

链式队列的入队操作

void linkedEnqueue(LinkedQueue *queue, int item) {


    QueueNode *newNode = (QueueNode *)malloc(sizeof(QueueNode));


    newNode->data = item;


    newNode->next = NULL;


    if (queue->rear == NULL) {


        queue->front = queue->rear = newNode;


    } else {


        queue->rear->next = newNode;


        queue->rear = newNode;


    }


    queue->size++;


    printf("%d enqueued to queuen", item);


}

链式队列的出队操作

int linkedDequeue(LinkedQueue *queue) {


    if (queue->front == NULL) {


        printf("Queue is empty!n");


        return -1;


    }


    QueueNode *temp = queue->front;


    int item = temp->data;


    queue->front = queue->front->next;


    if (queue->front == NULL) {


        queue->rear = NULL;


    }


    free(temp);


    queue->size--;


    return item;


}

八、队列的高级功能

在某些应用场景中，队列需要支持更高级的功能，例如优先级队列和双端队列。

优先级队列

优先级队列允许元素根据优先级进行出队，常见的实现方式有二叉堆。

typedef struct {


    int *array;


    int capacity;


    int size;


} PriorityQueue;


// 初始化优先级队列


PriorityQueue* createPriorityQueue(int capacity) {


    PriorityQueue *queue = (PriorityQueue *)malloc(sizeof(PriorityQueue));


    queue->capacity = capacity;


    queue->array = (int *)malloc(queue->capacity * sizeof(int));


    queue->size = 0;


    return queue;


}


// 插入元素到优先级队列


void insert(PriorityQueue *queue, int item) {


    if (queue->size == queue->capacity) {


        printf("Priority Queue is full!n");


        return;


    }


    queue->array[queue->size] = item;


    queue->size++;


    // 上浮操作以保持堆性质


    for (int i = queue->size - 1; i > 0 && queue->array[(i - 1) / 2] < queue->array[i]; i = (i - 1) / 2) {


        int temp = queue->array[i];


        queue->array[i] = queue->array[(i - 1) / 2];


        queue->array[(i - 1) / 2] = temp;


    }


}


// 删除优先级队列的最大元素


int extractMax(PriorityQueue *queue) {


    if (queue->size == 0) {


        printf("Priority Queue is empty!n");


        return -1;


    }


    int max = queue->array[0];


    queue->array[0] = queue->array[queue->size - 1];


    queue->size--;


    // 下沉操作以保持堆性质


    int i = 0;


    while (i * 2 + 1 < queue->size) {


        int maxChild = i * 2 + 1;


        if (maxChild + 1 < queue->size && queue->array[maxChild] < queue->array[maxChild + 1]) {


            maxChild++;


        }


        if (queue->array[i] >= queue->array[maxChild]) {


            break;


        }


        int temp = queue->array[i];


        queue->array[i] = queue->array[maxChild];


        queue->array[maxChild] = temp;


        i = maxChild;


    }


    return max;


}

双端队列

双端队列允许在队列的两端进行插入和删除操作。

typedef struct {


    int *array;


    int capacity;


    int size;


    int front;


    int rear;


} Deque;


// 初始化双端队列


Deque* createDeque(int capacity) {


    Deque *deque = (Deque *)malloc(sizeof(Deque));


    deque->capacity = capacity;


    deque->array = (int *)malloc(deque->capacity * sizeof(int));


    deque->size = 0;


    deque->front = -1;


    deque->rear = 0;


    return deque;


}


// 从队列前端插入


void insertFront(Deque *deque, int item) {


    if (deque->size == deque->capacity) {


        printf("Deque is full!n");


        return;


    }


    deque->front = (deque->front - 1 + deque->capacity) % deque->capacity;


    deque->array[deque->front] = item;


    deque->size++;


    printf("%d inserted to frontn", item);


}


// 从队列后端插入


void insertRear(Deque *deque, int item) {


    if (deque->size == deque->capacity) {


        printf("Deque is full!n");


        return;


    }


    deque->rear = (deque->rear + 1) % deque->capacity;


    deque->array[deque->rear] = item;


    deque->size++;


    printf("%d inserted to rearn", item);


}


// 从队列前端删除


int deleteFront(Deque *deque) {


    if (deque->size == 0) {


        printf("Deque is empty!n");


        return -1;


    }


    int item = deque->array[deque->front];


    deque->front = (deque->front + 1) % deque->capacity;


    deque->size--;


    return item;


}


// 从队列后端删除


int deleteRear(Deque *deque) {


    if (deque->size == 0) {


        printf("Deque is empty!n");


        return -1;


    }


    int item = deque->array[deque->rear];


    deque->rear = (deque->rear - 1 + deque->capacity) % deque->capacity;


    deque->size--;


    return item;


}

九、总结

在C语言中实现队列可以采用数组或链表的方式，具体的选择依赖于应用场景和需求。定义数据结构、初始化队列、入队操作、出队操作是实现队列的基本步骤。根据不同的需求，还可以实现优先级队列和双端队列等高级功能。无论哪种实现方式，都需要确保操作的正确性和队列性质的保持。通过这些步骤和代码示例，您应该能够在C语言中实现一个功能完整的队列。

相关问答FAQs：

1. 什么是队列？在C语言中如何实现队列？

队列是一种常见的数据结构，遵循先进先出（FIFO）的原则。在C语言中，可以通过数组或链表来实现队列。使用数组实现队列时，可以利用两个指针分别指向队列的前端和后端，并使用相应的操作来插入和删除元素。使用链表实现队列时，每个节点包含一个数据元素和一个指向下一个节点的指针，通过操作链表节点来实现队列的插入和删除操作。

2. 如何向队列中插入数据？

在C语言中，向队列中插入数据需要执行以下步骤：

  • 确定队列是否已满，如果已满则无法插入数据。
  • 如果队列为空，则将插入的元素同时作为队列的前端和后端。
  • 如果队列不为空，则将插入的元素放置在队列的后端，并更新后端指针。

3. 如何从队列中删除数据？

在C语言中，从队列中删除数据需要执行以下步骤：

  • 确定队列是否为空，如果为空则无法删除数据。
  • 如果队列只有一个元素，则将队列置为空。
  • 如果队列有多个元素，则将队列的前端指针向后移动一位，并返回被删除的元素。

请注意，以上是一种基本的队列实现方法，具体的实现细节可能因不同的情况而有所不同。

原创文章，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/1179268

赞 (0)
Edit1Edit1
上一篇 2024年8月29日 下午8:02
下一篇 2024年8月29日 下午8:02
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部