【数据结构】链式队列

1. queue.h

/*
* File Name: queue.h
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#ifndef __QUEUE_H__
#define __QUEUE_H__

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

#ifdef __cplusplus
extern "C" {
#endif

typedef int queue_data_t;
typedef struct node_s {
    queue_data_t data;
    struct node_s *next;
} node_t;

typedef struct queue_s {
    node_t *front;
    node_t *rear;
    int size;
} queue_t;

void init_queue(queue_t *queue);

int get_queue_size(const queue_t *queue);

int is_queue_empty(const queue_t *queue);

void print_queue(const queue_t *queue);

void push(queue_t *queue, queue_data_t data);

void pop(queue_t *queue);

queue_data_t get_front(const queue_t *queue);

queue_data_t get_back(const queue_t *queue);

void destroy_queue(queue_t *queue);

#ifdef __cplusplus
}
#endif

#endif // __QUEUE_H__

2. queue.c

/*
* File Name: queue.c
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#include "queue.h"

#include <limits.h>

void init_queue(queue_t *queue)
{
    queue->front = queue->rear = NULL;
    queue->size = 0;
}

int get_queue_size(const queue_t *queue)
{
    return queue->size;
}

int is_queue_empty(const queue_t *queue)
{
    return 0 == get_queue_size(queue);
}

void print_queue(const queue_t *queue)
{
    node_t *cur = queue->front;
    while (NULL != cur) {
        printf("%-2d -> ", cur->data);
        cur = cur->next;
    }

    printf("NULL\n");
}

void push(queue_t *queue, queue_data_t data)
{
    node_t *new_node = (node_t *)calloc(1, sizeof(node_t));
    if (NULL == new_node) {
        perror("calloc new_node fail");
        return;
    }

    new_node->next = NULL;
    new_node->data = data;
    ++queue->size;

    if (NULL == queue->rear) {
        queue->front = queue->rear = new_node;
    } else {
        queue->rear->next = new_node;
        queue->rear = new_node;
    }
}

void pop(queue_t *queue)
{
    if (is_queue_empty(queue)) {
        return;
    }

    node_t *pop_node = queue->front;
    queue->front = pop_node->next;
    free(pop_node);

    --queue->size;

    if (NULL == queue->front) {
        queue->rear = queue->front;
    }
}

queue_data_t get_front(const queue_t *queue)
{
    if (!is_queue_empty(queue) && queue->front) {
        return queue->front->data;
    }

    return INT_MIN;
}

queue_data_t get_back(const queue_t *queue)
{
    if (!is_queue_empty(queue) && queue->rear) {
        return queue->rear->data;
    }

    return INT_MIN;
}

void destroy_queue(queue_t *queue)
{
    node_t *cur = queue->front;
    node_t *next_node = NULL;

    for (; NULL != cur; cur = next_node) {
        next_node = cur->next;
        free(cur);
    }

    queue->front = queue->rear = NULL;
    queue->size = 0;
}

3. test_queue.c

/*
* File Name: test_queue.c
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#include "queue.h"

void test()
{
    queue_t queue;
    init_queue(&queue);
    int i = 0;

    if (is_queue_empty(&queue)) {
        printf("queue is empty\n");
    } else {
        printf("queue is not empty\n");
    }
    printf("queue size: %d\n", get_queue_size(&queue));
    printf("queue info: \n");
    print_queue(&queue);
    printf("queue front data: %d\n", get_front(&queue));
    printf("queue back data: %d\n", get_back(&queue));

    printf("========== push data===========\n");
    for (; i < 5; ++i) {
        push(&queue, i);
        printf("push [%d]\n", i);
    }
    printf("queue size: %d\n", get_queue_size(&queue));

    // printf("========== destroy data===========\n");
    // destroy_queue(&queue);

    printf("========== pop data===========\n");
    for (i = 0; i < 5; ++i) {
        printf("queue front data: %d\n", get_front(&queue));
        printf("queue back data: %d\n", get_back(&queue));
        pop(&queue);
    }

    if (is_queue_empty(&queue)) {
        printf("queue is empty\n");
    } else {
        printf("queue is not empty\n");
    }
    printf("queue size: %d\n", get_queue_size(&queue));
}

int main(void)
{
    test();

    return 0;
}