c语言 队列

queue.c

#pragma GCC optimize 0
#include "sys.h"

#define MAXNUM 10

struct testQuene arrayQuene[MAXNUM];
int first_in, last_out;
char *str;
void _quene()
{
    struct testQuene *quene;
    quene = arrayQuene;
    _initQuene(quene);      //初始化
    test(quene, 1, 10);     //1调用增加函数 循环10次，
    _findQuene(quene, 588); //查找函数
    test(quene, 2, 1);      //2调用修改函数 循环1次，
    test(quene, 0, 4);      //0调用删除函数 循环4次，
    test(quene, 1, 3);      //1调用增加函数 循环3次，
    test(quene, 0, 9);      //0调用删除函数 循环9次，
}
void ss(struct testQuene *q)
{
    q->data = 55;
}
//初始化
void _initQuene(struct testQuene *q)
{
    first_in = 0;
    last_out = 0;
    for (int i = 0; i < MAXNUM; i++)
    {
        q[i].data = i;
    }
}
//增加数据
struct testQuene *_addQuene(struct testQuene *q, int addNum)
{
    str = "overflow";
    if (!_isOverflow(1))
        return q;
    q[first_in].data = addNum;
    _loopPointer(1); //1 首指针移位 0 尾指针移位
    str = "successful";
    return q;
}
//删除数据
struct testQuene *_deleteQuene(struct testQuene *q)
{
    str = "failed,lack of data!";
    if (!_isOverflow(0)) // 1：判断是否溢出 0：判断是否空数据
        return q;
    q[last_out].data = 0;
    _loopPointer(0); //1 首指针移位 0 尾指针移位
    str = "successful";
    return q;
}
//判断是否溢出和空数据 n:0判断空数据 1判断溢出；返回值0代表空和溢出，1代表相反
int _isOverflow(int n)
{
    switch (n)
    {
    case 0: //0判断空数据
        return last_out == first_in ? 0 : 1;
    case 1: //1判断溢出
        return (first_in + 1) % MAXNUM == last_out ? 0 : 1;
    }
}
//判断指针循环移位
void _loopPointer(int n)
{
    switch (n)
    {
    case 0: // 删除尾指针移位
        last_out++;
        last_out %= MAXNUM;
        break;
    case 1: // 增加首指针移位
        first_in++;
        first_in %= MAXNUM;
        break;
    }
}

//查找数据
void _findQuene(struct testQuene *q, int findNum)
{
    for (int i = last_out; i < first_in; i++)
    {
        if (q[i].data == findNum)
        {
            str = "I found it already!";
            break;
        }
        else
            str = "not exist!!";
    }
}
//修改数据
struct testQuene *_changeQuene(struct testQuene *q, int oldNum, int newNum)
{
    for (int i = last_out; i < first_in; i++)
    {
        if (q[i].data == oldNum)
        {
            q[i].data = newNum;
            str = "change successful!";
            break;
        }
        else
            str = "not exist!!";
    }
    return q;
}

//n 选择调用函数 0调用删除 1调用增加 2调用修改；num循环次数
void test(struct testQuene *quene, int n, int num)
{
    switch (n)
    {
    case 0: //调用删除数据函数
        for (int i = 0; i < num; i++)
            quene = _deleteQuene(quene); //循环num次操作
        break;
    case 1: //调用增加数据函数
        for (int i = 0; i < num; i++)
            quene = _addQuene(quene, 555 + i); //循环num次操作
        break;
    case 2: //调用修改数据函数
        for (int i = 0; i < num; i++)
            quene = _changeQuene(quene, 557, 666); //循环num次操作
        break;
    }
}

sys.c

#pragma GCC optimize 0
#include "main.h"

void setup(void)
{
}

int i = 0;
void loop()
{
  i++;
  _quene();
}

sys.h

#ifndef _SYS_H
#define _SYS_H
void setup(void);
void loop();
struct testQuene
{
    int data;
};
void _initQuene(struct testQuene *q);                                        //初始化
struct testQuene *_addQuene(struct testQuene *q, int addNum);                //增加数据
struct testQuene *_deleteQuene(struct testQuene *q);                         //删除数据
void _findQuene(struct testQuene *q, int findNum);                           //查找数据
struct testQuene *_changeQuene(struct testQuene *q, int oldNum, int newNum); //修改数据
int _isOverflow(int n);                                                      //判断是否溢出和空数据 n:0判断空数据 1判断溢出；返回值0代表空和溢出，1代表相反
void _loopPointer(int n);                                                    //判断指针循环移位
void test(struct testQuene *quene, int n, int num);                          //n 选择调用函数 0调用删除 1调用增加；num循环次数

#endif