第二十四天（数据结构：栈和队列）队列实践补充

链表队列

.h与.c

#ifndef LISTQUEUE_H
#define LISTQUEUE_H

typedef int LQ_DataType;
#define LQ_ERRORVALUE (LQ_DataType)(1 << 31)


#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
//队列节点
typedef struct LQ_Node {
    LQ_DataType _data;
    struct LQ_Node * _next;
}LQ_Node;
//队列头节点
typedef struct {
    LQ_Node * _front;
    LQ_Node * _rear;
    int _num;
    int _maxnum;
}LQ_HeadNode;

//开队列头节点
LQ_HeadNode * LQ_init(int maxnum);
//开队列节点
static LQ_Node * LQ_Node_Create(const LQ_DataType data);
//判断是否为空
bool LQ_empty(LQ_HeadNode * qu);
//判断是否为满
bool LQ_full(LQ_HeadNode * qu);
//返回对头元素（删除使用）
LQ_DataType LQ_front(LQ_HeadNode * qu);
//返回元素个数
int LQ_size(LQ_HeadNode * qu);
//入队
bool LQ_push(LQ_HeadNode * qu,const LQ_DataType data);
//出队
bool LQ_pop(LQ_HeadNode * qu,void(*callback)(const LQ_DataType data));
//清空队列
void LQ_clear(LQ_HeadNode * qu,void(*callback)(const LQ_DataType data));
//销毁队列
void LQ_destory(LQ_HeadNode ** qu,void(*callback)(const LQ_DataType data));






#endif //LISTQUEUE_H

#include "ListQueue.h"
//开队列头节点
LQ_HeadNode * LQ_init(int maxnum) {
    if (maxnum <= 0) {
        printf("蠢猪，我给你开\n");
        maxnum = 10000000;
    }
    LQ_HeadNode * qu = (LQ_HeadNode *)calloc(1,sizeof(LQ_HeadNode));
    qu ->_maxnum = maxnum;
    return qu;
}
//开队列节点
static LQ_Node * LQ_Node_Create(const LQ_DataType data) {
    LQ_Node * node = (LQ_Node *)calloc(1,sizeof(LQ_Node));
    node ->_data = data;
    return node;
}
//判断是否为空
bool LQ_empty(LQ_HeadNode * qu) {
    if (!qu || qu ->_num == 0) {
        return true;
    }
    return false;
}
//判断是否为满
bool LQ_full(LQ_HeadNode * qu) {
    if (!qu || qu ->_num == qu ->_maxnum) {
        return true;
    }
    return false;
}
//返回对头元素（删除使用）
LQ_DataType LQ_front(LQ_HeadNode * qu) {
    if (LQ_empty(qu)) {
        return LQ_ERRORVALUE;
    }
    return qu ->_front ->_data;
}
//返回元素个数
int LQ_size(LQ_HeadNode * qu) {
    if (LQ_empty(qu)) {
        return 0;
    }
    return qu ->_num;
}
//入队
bool LQ_push(LQ_HeadNode * qu,const LQ_DataType data) {
    if (!qu || LQ_full(qu)) {
        return false;
    }
    LQ_Node * ptr = LQ_Node_Create(data);
    if (LQ_empty(qu))
    qu ->_rear = qu ->_front = ptr;
    else {
        qu ->_rear ->_next = ptr;
        qu ->_rear = ptr;
    }
    qu ->_num++;
    return true;

}
//出队
bool LQ_pop(LQ_HeadNode * qu,void(*callback)(const LQ_DataType data)) {
    if (LQ_empty(qu)) {
        return false;
    }
    LQ_DataType data = LQ_front(qu);
    if (callback && LQ_ERRORVALUE != data) {
        callback(data);
    }
    LQ_Node * ptr = qu ->_front;
    if (qu ->_front == qu ->_rear) {
        qu ->_front = qu ->_rear = NULL;
    }
    else {

        qu ->_front = qu ->_front ->_next;
        ptr ->_next =NULL;
    }
    free(ptr);
    qu ->_num--;
    return true;
}
//清空队列
void LQ_clear(LQ_HeadNode * qu,void(*callback)(const LQ_DataType data)) {
    if (!qu) {
        return;
    }
    while (!LQ_empty(qu)) {
        LQ_pop(qu,callback);
    }
}
//销毁队列
void LQ_destory(LQ_HeadNode ** qu,void(*callback)(const LQ_DataType data)) {
    if (!qu) {
        return;
    }
    LQ_clear(*qu,callback);
    free(*qu);
    *qu = NULL;
}

顺序队列：

.h与.c

#ifndef __ARRAYQUEUE_H_
#define __ARRAYQUEUE_H_




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

typedef int AQ_DataType;
#define AQ_ERRORVALUE (AQ_DataType)(1 << 31)//队列的错误值

#define flase false



typedef struct//同样是为了管理我们的队列的
{
    //int _qu_arr[100000];//容纳所有的队列里面的元素
    AQ_DataType * _qu_arr;//我给你开辟一个数组出来让_qu_arr去保存
    int  _front;//指向对头元素的 指向要删除的数据
    int _rear;//指向队尾元素 指向要插入的数据
    //为了防止爆队(溢出)  我们可以弄一个最大值来进行限定
    int _maxnum; // 实际队列容纳个数为 maxnum - 1
    //int _qu_arr[0]; // 柔性数组  本身不占一个字节  你多开多少个字节 _qu_arr就占多少字节
}ArrayQueue;


//init        初始化这个队列
//maxnum如果小于等于0  则默认为 10000000
ArrayQueue * ArrayQueue_init(int maxnum);

//front       返回队头元素，但是不出队
//返回AQ_ERRORVALUE表示错误值
AQ_DataType ArrayQueue_front(ArrayQueue * qu);

//empty       判断是否为空
bool ArrayQueue_empty(ArrayQueue * qu);

//full        判断是否为满
bool ArrayQueue_full(ArrayQueue * qu);

//size        返回元素个数
int ArrayQueue_size(ArrayQueue * qu);

//push(inqueue)        入队  rear插入
void ArrayQueue_push(ArrayQueue * qu,const AQ_DataType data);

//pop(outqueue)         出队，不返回元素
void ArrayQueue_pop(ArrayQueue * qu);

//clear       清空这个队列
//callback为空表示不处理数据  不为空则表示要处理数据 请使用者将规则传进来
void ArrayQueue_clear(ArrayQueue * qu,void (*callback)(const AQ_DataType));

//destory     销毁这个队列
void ArrayQueue_destory(ArrayQueue ** qu,void (*callback)(const AQ_DataType));


#endif

#include "ArrayQueue.h"


//init        初始化这个队列
//maxnum如果小于等于0  则默认为 10000000
ArrayQueue * ArrayQueue_init(int maxnum)
{
    if(maxnum <= 0)
        maxnum = 10000000;
    ArrayQueue * qu = (ArrayQueue *)calloc(1,sizeof(ArrayQueue));
    qu ->_maxnum = maxnum;
    //总共开辟maxnum个元素  实际容纳maxnum - 1
    qu ->_qu_arr = (AQ_DataType *)calloc(maxnum,sizeof(AQ_DataType));
    return qu;
}
//front       返回队头元素，但是不出队
//返回AQ_ERRORVALUE表示错误值
AQ_DataType ArrayQueue_front(ArrayQueue * qu)
{
    if(ArrayQueue_empty(qu))
        return AQ_ERRORVALUE;
    return qu ->_qu_arr[qu ->_front];
}
//empty       判断是否为空
bool ArrayQueue_empty(ArrayQueue * qu)
{
    if(!qu || qu ->_front == qu ->_rear)
        return true;
    return false;
}
//full        判断是否为满
bool ArrayQueue_full(ArrayQueue * qu)
{
    if(!qu || (qu ->_rear + 1) % qu ->_maxnum == qu ->_front)
        return true;//ture
    return false;
}

//size        返回元素个数
int ArrayQueue_size(ArrayQueue * qu)
{
    if(!qu)
        return 0;
    return (qu ->_rear - qu ->_front + qu ->_maxnum) % qu ->_maxnum;
}

//push(inqueue)        入队  rear插入
void ArrayQueue_push(ArrayQueue * qu,const AQ_DataType data)
{
    if(ArrayQueue_full(qu))
        return;
    qu ->_qu_arr[qu ->_rear] = data;
    qu ->_rear = (qu ->_rear + 1) % qu ->_maxnum;//要求余  否则会假溢出
}

//pop(outqueue)         出队，不返回元素
void ArrayQueue_pop(ArrayQueue * qu)
{
    if(ArrayQueue_empty(qu))
        return;
    qu ->_front = (qu ->_front + 1) % qu ->_maxnum;////要求余  否则会假溢出
}

//clear       清空这个队列
//callback为空表示不处理数据  不为空则表示要处理数据 请使用者将规则传进来
void ArrayQueue_clear(ArrayQueue * qu,void (*callback)(const AQ_DataType))
{
    if(ArrayQueue_empty(qu))
        return;
    if(!callback)//如果不处理用户的数据   直接将_front _rear置为相等，一般都是置0
    {
        qu ->_front = qu ->_rear = 0;
        return;
    }  
    while(!ArrayQueue_empty(qu))//不是空的就一直出
    {
        AQ_DataType data = ArrayQueue_front(qu);
        ArrayQueue_pop(qu);
        if(callback && AQ_ERRORVALUE != data)
        {
            callback(data);
        }
    }
}
//destory     销毁这个队列
void ArrayQueue_destory(ArrayQueue ** qu,void (*callback)(const AQ_DataType))
{
    if(!qu)
        return;
    ArrayQueue_clear(*qu,callback);
    free((*qu) ->_qu_arr);//先释放这个
    free(*qu);
    *qu = NULL;
}