队列——C语言（动态数组）

接下来我将用malloc函数实现队列的动态数组版本

提示：malloc函数是C语言中分配内存空间的函数

1.首先，按照惯例，先写一个队列的接口（queue.h）

/*
一个队列模块的接口
*/
#include <stdlib.h>

#define QUEUE_TYPE int /*队列元素的类型*/

/*
** create_queue
** 创建一个队列，参数为队列可以存储元素的最大数量
** 这个函数只适用于动态分配数组的队列版本
*/
void create_queue(size_t size);

/*
** destroy_queue
** 销毁一个队列，只适用于链式和动态分配数组的版本
*/
void destroy_queue(void);

/*
** insert
** 向队列添加一个新元素，参数为要添加的元素
*/
void insert(QUEUE_TYPE value);

/*
** delete
** 从队列中移除一个元素
*/
void delete(void);

/*
** first
** 返回队列中第一个元素的值，队列不动
*/
QUEUE_TYPE first(void);

/*
** last
** 返回队列最后一个元素的值，队列不动
*/
QUEUE_TYPE last(void);

/*
** is_empty
** 如果队列为空，返回1,否则返回0
*/
int is_empty(void);

/*
** is_full
** 如果队列为满，返回1,否则返回0
*/
int is_full(void);

/*
** aqueue_print
** 遍历打印队列(数组版本),并返回队列存储元素个数
*/
int aqueue_print(void);

/*
** lqueue_print
** 遍历打印队列(链表版本),并返回队列存储元素个数
*/
int lqueue_print(void);

2.然后再写一个文件具体实现函数操作（d_queue.c）

/*
** 动态数组实现队列，
** 数组为环形数组,
** 队列的大小通过define更改
** 数组的大小=队列大小+1，用以区分队列是否为空或满
** 该技巧称之为“不完全填满数组”
** 一个指针指向队列头，一个指针指向队列尾
** 当队列为空时，尾指针=头指针-1
** 当队列只有一个元素时，头尾指针相等
** 向队列插入元素时，尾指针rear增
** 队列移除元素时，头指针front增                     
*/
#include "queue.h"
#include <stdio.h>
#include <assert.h>
#include <malloc.h>

/*
** 定义环形数组的大小、指向队列指针以及队列头尾指针
*/
static int ARRAY_SIZE;
static QUEUE_TYPE *queue;
static size_t front = 1;
static size_t rear = 0;

/*
** create_queue
*/
void create_queue(size_t size){
    ARRAY_SIZE = size + 1;
    queue = malloc(sizeof(QUEUE_TYPE) * ARRAY_SIZE);
    assert(queue != NULL);
}

/*
** destroy_queue
*/
void destroy_queue(void){
    free(queue);
    queue = NULL;
}

/*
** insert
*/
void insert(QUEUE_TYPE value){
    assert( !is_full() );
    rear = (rear + 1) % ARRAY_SIZE;
    queue[rear] = value;
}

/*
** delete
*/
void delete(void){
    assert( !is_empty() );
    front = (front + 1) % ARRAY_SIZE;
}

/*
** first
*/
QUEUE_TYPE first(void){
    assert( !is_empty() );
    return queue[front];
}

/*
** last
*/
QUEUE_TYPE last(void){
    assert( !is_empty() );
    return queue[rear];
}

/*
** is_empty
*/
int is_empty(void){
    return (rear + 1) % ARRAY_SIZE == front;
}

/*
** is_full
*/
int is_full(void){
    return (rear + 2) % ARRAY_SIZE == front;
}

/*
** aqueue_print
*/
int aqueue_print(void){
    size_t find = front;
    int count = 0;
    while(find != (rear + 1) % ARRAY_SIZE){
        printf("[%d]:%d", find, queue[find]);
        ++count;
        find = (find + 1) % ARRAY_SIZE;
        if(find != (rear + 1) % ARRAY_SIZE)
            printf(",");
    }
    return count;
}

3.最后编写一个主函数来测试（d_main.c）

#include "d_queue.c"

int main(){
    create_queue(5);
    insert(23);
    insert(12);
    insert(56);
    insert(34);
    insert(21);
    printf("\n该队列存储了%d个元素\n",aqueue_print());
    printf("队列满员了？%s", is_full()?"True":"False");
    printf("\n队列头元素为%d，尾元素为%d\n\n", first(), last());
    delete();
    delete();
    printf("\n该队列存储了%d个元素\n",aqueue_print());
    printf("队列满员了？%s", is_full()?"True":"False");
    printf("\n队列头元素为%d，尾元素为%d\n\n", first(), last());
    destroy_queue();
    return 0;
}

控制台输出：

[1]:23,[2]:12,[3]:56,[4]:34,[5]:21    
该队列存储了5个元素
队列满员了？True
队列头元素为23，尾元素为21

[3]:56,[4]:34,[5]:21
该队列存储了3个元素
队列满员了？False
队列头元素为56，尾元素为21

总结：到此，我已经用静态、动态数组实现了队列，但是我觉得还是有点繁琐，接下来我会用链表的形式来写队列。