/*
 * 顺序存储队列
 */

#ifndef SEQQUEUE_H__
#define SEQQUEUE_H__

// 定义 5 块空间，会有一块空间不能用
#define MAXSIZE 5

// 顺序存储队列元素类型定义
typedef int datatype;

/*
 * 顺序存储队列结构
 * 使用定长数组来存储数据元素
 */
typedef struct node_st {
    datatype data[MAXSIZE];
    int head, tail; // 队列的队首和队尾
}seqqueue;

/*
 * 初始化，创建队列
 * 返回结构体类型的指针
 */
seqqueue *seqqueue_create();

/*
 * 判断队列是否为空
 */
int seqqueue_is_empty(seqqueue *);

/*
 * 入队列
 */
int seqqueue_push(seqqueue *, datatype *);

/*
 * 出队列
 */
int seqqueue_pop(seqqueue *, datatype *);

/*
 * 遍历队列
 */
void seqqueue_travel(seqqueue *);

/*
 * 清空队列
 */
void seqqueue_clear(seqqueue *);

/*
 * 销毁队列
 */
void seqqueue_destroy(seqqueue *);

#endif

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

#include "seqqueue.h"

/*
 * 初始化，创建队列
 * 返回结构体类型的指针
 */
seqqueue *seqqueue_create() {
    seqqueue *ptr;
    ptr = malloc(sizeof(*ptr));
    if (ptr == NULL) {
        return NULL;
    }

    // 初始化队列的队首、队尾
    ptr->head = 0;
    ptr->tail = 0;
    return ptr;
}

/*
 * 判断队列是否为空
 */
int seqqueue_is_empty(seqqueue *ptr) {
    return (ptr->head == ptr->tail);
}

/*
 * 入队列
 */
int seqqueue_push(seqqueue *ptr, datatype *data) {
    if ((ptr->tail + 1) % MAXSIZE == ptr->head) {
        // 队列已满
        return -1;
    }
    // 数据从队尾插入
    ptr->tail = (ptr->tail + 1) % MAXSIZE;
    ptr->data[ptr->tail] = *data;
    return 0;
}

/*
 * 出队列
 */
int seqqueue_pop(seqqueue *ptr, datatype *data) {
    if (seqqueue_is_empty(ptr)) {
        return -1;
    }
    // 数据从队首删除
    ptr->head = (ptr->head + 1) % MAXSIZE;
    *data = ptr->data[ptr->head];
    return 0;
}

/*
 * 遍历队列
 */
void seqqueue_travel(seqqueue *ptr) {
    int i; // 循环索引值
    if (seqqueue_is_empty(ptr)) {
        // 队列为空
        return; // 无返回值
    }

    // 队首元素所在位置
    i = (ptr->head + 1) % MAXSIZE;
    while (i != ptr->tail) {
        printf("%d ", ptr->data[i]);
        i = (i + 1) % MAXSIZE;
    }
    printf("%d\n", ptr->data[i]);
    return; // 无返回值
}

/*
 * 清空队列
 */
void seqqueue_clear(seqqueue *ptr) {
    ptr->head = ptr->tail;
    return; // 无返回值
}

/*
 * 销毁队列
 */
void seqqueue_destroy(seqqueue *ptr) {
    free(ptr);
    return; // 无返回值
}

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

#include "seqqueue.h"

int main() {
    int i; // 循环索引值
    int ret; // 状态返回值
    seqqueue *queue = NULL; // 顺序存储队列
    // 测试数据
    datatype arr[] = {23, 93, 52, 66};
    datatype op_data = 75; // 操作中的数据

    /* 初始化顺序存储队列 */
    queue = seqqueue_create();
    if (queue == NULL) {
        fprintf(stderr, "初始化顺序存储队列 queue 失败！\n");
        exit(1);
    }
    /* 数据入队 */
    for (i = 0; i < sizeof(arr)/sizeof(*arr); i++) {
        seqqueue_push(queue, &arr[i]);
    }
    /* 遍历队列 */
    printf("队列中的元素：");
    seqqueue_travel(queue);
    /* 数据入队 */
    ret = seqqueue_push(queue, &op_data);
    if (ret == -1) {
        printf("队列已満！无法继续入队！\n");
    } else {
        /* 遍历队列 */
        printf("队列中的元素：");
        seqqueue_travel(queue);
    }

    /* 数据出队 */
    seqqueue_pop(queue, &op_data);
    printf("出队：%d\n", op_data);

    /* 遍历队列 */
    printf("队列中的元素：");
    seqqueue_travel(queue);

    /* 销毁队列 */
    seqqueue_destroy(queue);
    exit(0);
}

OBJS=main.o seqqueue.o
CC=gcc
CFLAGS+=-c -Wall -g
seqqueue:$(OBJS)
    $(CC) $^ -o $@
%.o:%.c
    $(CC) $^ $(CFLAGS) -o $@
clean:
    $(RM) *.o seqqueue -r

root@RicenOS:~# make
gcc main.c -c -Wall -g -o main.o
gcc seqqueue.c -c -Wall -g -o seqqueue.o
gcc main.o seqqueue.o -o seqqueue
root@RicenOS:~# ./seqqueue
队列中的元素：23 93 52 66
队列已満！无法继续入队！
出队：23
队列中的元素：93 52 66