数据结构队列

队列也是一种数据结构
队列也可以用来存储数字，这些数字在队列里
也是有顺序的
获得的数字一定是最先放进去的数字
这种使用规则叫先进先出
实现队列的时候需要提供一个函数用来向队列里
放数字(push)
实现队列的时候需要提供一个函数用来从队列里
获得数字(pop)

/*
    队列演示
*/
#ifndef       __01QUEUE_H__
#define       __01QUEUE_H__
typedef struct {
    int buf[SIZE];
    int head/*第一个数字所在存储区的下标*/, tail/*第一个空位置所在的下标*/;
} queue;
//初始化函数
void queue_init(queue *);
//清理函数
void queue_deinit(queue *);
//判断队列是否空的函数
int queue_empty(const queue *);
//判断队列是否满的函数
int queue_full(const queue *);
//获得数字个数的函数
int queue_size(const queue *);
//向队列里添加数字的函数
void queue_push(queue *, int );
//从队列里拿走数字的函数
int queue_pop(queue *);
//从队列里获得数字的函数
int queue_front(const queue *);
#endif    //__01QUEUE_H__





/*
    队列演示
*/
#include "01queue.h"
//初始化函数
void queue_init(queue *p_queue) {
    p_queue->head = 0;
    p_queue->tail = 0;
}
//清理函数
void queue_deinit(queue *p_queue) {
    p_queue->head = 0;
    p_queue->tail = 0;
}
//判断队列是否空的函数
int queue_empty(const queue *p_queue) {
    return p_queue->head == p_queue->tail;
}
//判断队列是否满的函数
int queue_full(const queue *p_queue) {
    return p_queue->tail == SIZE;
}
//获得数字个数的函数
int queue_size(const queue *p_queue) {
    return p_queue->tail - p_queue->head;
}
//向队列里添加数字的函数
void queue_push(queue *p_queue, int num) {
    p_queue->buf[p_queue->tail] = num;
    p_queue->tail++;
}
//从队列里拿走数字的函数
int queue_pop(queue *p_queue) {
    int ret = p_queue->buf[p_queue->head];
    p_queue->head++;
    return ret;
}
//从队列里获得数字的函数
int queue_front(const queue *p_queue) {
    return p_queue->buf[p_queue->head];
}






/*
    队列测试
*/
#include <stdio.h>
#include "01queue.h"
int main() {
    queue que = {0};
    queue_init(&que);
    queue_push(&que, 10);
    queue_push(&que, 20);
    queue_push(&que, 30);
    queue_push(&que, 40);
    queue_push(&que, 50);
    queue_push(&que, 60);
    printf("数字个数是%d\n", queue_size(&que));
    printf("%d\n", queue_pop(&que));
    printf("%d\n", queue_pop(&que));
    printf("%d\n", queue_pop(&que));
    printf("判断满的结果是%d\n", queue_full(&que));
    if (!queue_full(&que)) {
        queue_push(&que, 70);
        queue_push(&que, 80);
        printf("%d\n", queue_pop(&que));
        printf("%d\n", queue_pop(&que));
    }
    printf("%d\n", queue_pop(&que));
    printf("%d\n", queue_pop(&que));
    printf("%d\n", queue_pop(&que));
    printf("判断空的结果是%d\n", queue_empty(&que));
    queue_deinit(&que);
    return 0;
}

/*
    队列演示
*/
#ifndef       __02QUEUE_H__
#define       __02QUEUE_H__
typedef struct {
    int buf[SIZE];
    int head/*第一个数字所在存储区的下标*/, tail/*第一个空位置所在的下标*/;
    int num;
} queue;
//初始化函数
void queue_init(queue *);
//清理函数
void queue_deinit(queue *);
//判断队列是否空的函数
int queue_empty(const queue *);
//判断队列是否满的函数
int queue_full(const queue *);
//获得数字个数的函数
int queue_size(const queue *);
//向队列里添加数字的函数
void queue_push(queue *, int );
//从队列里拿走数字的函数
int queue_pop(queue *);
//从队列里获得数字的函数
int queue_front(const queue *);
#endif    //__02QUEUE_H__





/*
    队列演示
*/
#include "02queue.h"
//初始化函数
void queue_init(queue *p_queue) {
    p_queue->head = 0;
    p_queue->tail = 0;
    p_queue->num = 0;
}
//清理函数
void queue_deinit(queue *p_queue) {
    p_queue->head = 0;
    p_queue->tail = 0;
    p_queue->num = 0;
}
//判断队列是否空的函数
int queue_empty(const queue *p_queue) {
    return !(p_queue->num);
}
//判断队列是否满的函数
int queue_full(const queue *p_queue) {
    return p_queue->num == SIZE;
}
//获得数字个数的函数
int queue_size(const queue *p_queue) {
    return p_queue->num;
}
//向队列里添加数字的函数
void queue_push(queue *p_queue, int num) {
    p_queue->buf[p_queue->tail] = num;
    p_queue->num++;
    p_queue->tail = (p_queue->tail + 1) % SIZE;
}
//从队列里拿走数字的函数
int queue_pop(queue *p_queue) {
    int ret = p_queue->buf[p_queue->head];
    p_queue->num--;
    p_queue->head = (p_queue->head + 1) % SIZE;
    return ret;
}
//从队列里获得数字的函数
int queue_front(const queue *p_queue) {
    return p_queue->buf[p_queue->head];
}





/*
    队列测试
*/
#include <stdio.h>
#include "02queue.h"
int main() {
    queue que = {0};
    queue_init(&que);
    queue_push(&que, 10);
    queue_push(&que, 20);
    queue_push(&que, 30);
    queue_push(&que, 40);
    queue_push(&que, 50);
    queue_push(&que, 60);
    printf("数字个数是%d\n", queue_size(&que));
    printf("%d\n", queue_pop(&que));
    printf("%d\n", queue_pop(&que));
    printf("%d\n", queue_pop(&que));
    printf("判断满的结果是%d\n", queue_full(&que));
    if (!queue_full(&que)) {
        queue_push(&que, 70);
        queue_push(&que, 80);
        printf("%d\n", queue_pop(&que));
        printf("%d\n", queue_pop(&que));
    }
    printf("%d\n", queue_pop(&que));
    printf("%d\n", queue_pop(&que));
    printf("%d\n", queue_pop(&que));
    printf("判断空的结果是%d\n", queue_empty(&que));
    queue_deinit(&que);
    return 0;
}

/*
    队列演示
*/
#ifndef       __03QUEUE_H__
#define       __03QUEUE_H__
typedef struct node {
    int num;
    struct node *p_next;
} node;
typedef struct {
    node head, tail;
} queue;
//初始化函数
void queue_init(queue *);
//清理函数
void queue_deinit(queue *);
//判断队列是否空的函数
int queue_empty(const queue *);
//判断队列是否满的函数
int queue_full(const queue *);
//获得数字个数的函数
int queue_size(const queue *);
//向队列里添加数字的函数
void queue_push(queue *, int );
//从队列里拿走数字的函数
int queue_pop(queue *);
//从队列里获得数字的函数
int queue_front(const queue *);
#endif    //__03QUEUE_H__





/*
    队列演示
*/
#include <stdlib.h>
#include "03queue.h"
//初始化函数
void queue_init(queue *p_queue) {
    p_queue->head.p_next = &(p_queue->tail);
    p_queue->tail.p_next = NULL;
}
//清理函数
void queue_deinit(queue *p_queue) {
    while (p_queue->head.p_next != &(p_queue->tail)) {
        node *p_first = &(p_queue->head);
        node *p_mid = p_first->p_next;
        node *p_last = p_mid->p_next;
        p_first->p_next = p_last;
        free(p_mid);
        p_mid = NULL;
    }
}
//判断队列是否空的函数
int queue_empty(const queue *p_queue) {
    return p_queue->head.p_next == &(p_queue->tail);
}
//判断队列是否满的函数
int queue_full(const queue *p_queue) {
    return 0;
}
//获得数字个数的函数
int queue_size(const queue *p_queue) {
    int cnt = 0;
    const node *p_node = NULL;
    for (p_node = &(p_queue->head);p_node != &(p_queue->tail);p_node = p_node->p_next) {
        const node *p_first = p_node;
        const node *p_mid = p_first->p_next;
        const node *p_last = p_mid->p_next;
        if (p_mid != &(p_queue->tail)) {
            cnt++;
        }
    }
    return cnt;
}
//向队列里添加数字的函数
void queue_push(queue *p_queue, int num) {
    node *p_node = NULL;
    node *p_tmp = (node *)malloc(sizeof(node));
    if (!p_tmp) {
        return ;
    }
    p_tmp->num = num;
    p_tmp->p_next = NULL;
    for (p_node = &(p_queue->head);p_node != &(p_queue->tail);p_node = p_node->p_next) {
        node *p_first = p_node;
        node *p_mid = p_first->p_next;
        node *p_last = p_mid->p_next;
        if (p_mid == &(p_queue->tail)) {
            p_first->p_next = p_tmp;
            p_tmp->p_next = p_mid;
            break;
        }
    }
}
//从队列里拿走数字的函数
int queue_pop(queue *p_queue) {
    node *p_first = NULL, *p_mid = NULL, *p_last = NULL;
    int ret = p_queue->head.p_next->num;
    p_first = &(p_queue->head);
    p_mid = p_first->p_next;
    p_last = p_mid->p_next;
    p_first->p_next = p_last;
    free(p_mid);
    p_mid = NULL;
    return ret;
}
//从队列里获得数字的函数
int queue_front(const queue *p_queue) {
    return p_queue->head.p_next->num;
}





/*
    队列测试
*/
#include <stdio.h>
#include "03queue.h"
int main() {
    queue que = {0};
    queue_init(&que);
    queue_push(&que, 10);
    queue_push(&que, 20);
    queue_push(&que, 30);
    queue_push(&que, 40);
    queue_push(&que, 50);
    queue_push(&que, 60);
    printf("数字个数是%d\n", queue_size(&que));
    printf("%d\n", queue_pop(&que));
    printf("%d\n", queue_pop(&que));
    printf("%d\n", queue_pop(&que));
    printf("判断满的结果是%d\n", queue_full(&que));
    if (!queue_full(&que)) {
        queue_push(&que, 70);
        queue_push(&que, 80);
        printf("%d\n", queue_pop(&que));
        printf("%d\n", queue_pop(&que));
    }
    printf("%d\n", queue_pop(&que));
    printf("%d\n", queue_pop(&que));
    printf("%d\n", queue_pop(&que));
    printf("判断空的结果是%d\n", queue_empty(&que));
    queue_deinit(&que);
    return 0;
}