队列的顺序存储实现

顺序存储队列头文件：

#pragma once
#include<stdlib.h>
#include<stdio.h>
#define MAX_SIZE 1024

//顺序队列结构体
typedef struct SEQQUEUE
{
    void *data[MAX_SIZE];
    int size;
}SeqQueue;

//初始化队列
SeqQueue* Init_SeqQueue();
//入队
void Push_SeqQueue(SeqQueue* queue, void* value);
//出队
void Pop_SeqQueue(SeqQueue* queue);
//返回队首元素
void* Front_SeqQueue(SeqQueue* queue);
//返回队尾元素
void* Back_SeqQueue(SeqQueue* queue);
//返回队列长度
int Size_SeqQueue(SeqQueue* queue);
//清空队列
void Clear_SeqQueue(SeqQueue* queue);
//销毁队列
void Free_SeqQueue(SeqQueue* queue);

顺序存储队列实现文件：

#include "队列顺序存储.h"
//初始化队列
SeqQueue* Init_SeqQueue()
{
    SeqQueue* queue = (SeqQueue*)malloc(sizeof(SeqQueue));
    if (queue == NULL)
    {
        exit(1);
    }

    queue->size = 0;
    for (int i = 0; i < MAX_SIZE; ++i)
    {
        queue->data[i] = NULL;
    }

    return queue;
}
//入队数组左边做队头
void Push_SeqQueue(SeqQueue* queue, void* value)
{
    if (queue == NULL)
    {
        exit(1);
    }

    if (value == NULL)
    {
        exit(1);
    }

    if (queue->size == MAX_SIZE)
    {
        exit(1);
    }

    queue->data[queue->size] = value;
    queue->size++;
}
//出队
void Pop_SeqQueue(SeqQueue* queue)
{
    if (queue == NULL)
    {
        exit(1);
    }

    if (queue->size == 0)
    {
        exit(1);
    }

    for (int i = 0; i < queue->size-1; ++i)
    {
        queue->data[i] = queue->data[i + 1];
    }
    queue->size--;
}
//返回队首元素
void* Front_SeqQueue(SeqQueue* queue)
{
    if (queue == NULL)
    {
        exit(1);
    }

    if (queue->size == 0)
    {
        exit(1);
    }

    return queue->data[0];
}
//返回队尾元素
void* Back_SeqQueue(SeqQueue* queue);
//返回队列长度
int Size_SeqQueue(SeqQueue* queue)
{
    if (queue == NULL)
    {
        exit(1);
    }

    return queue->size;
}
//清空队列
void Clear_SeqQueue(SeqQueue* queue)
{
    if (queue == NULL)
    {
        exit(1);
    }

    queue->size = 0;
}
//销毁队列
void Free_SeqQueue(SeqQueue* queue)
{
    if (queue == NULL)
    {
        exit(1);
    }
    
    for (int i = 0; i < MAX_SIZE; ++i)
    {
        queue->data[i] = NULL;
    }
    queue->size = 0;
    free(queue);
    
}

顺序存储队列测试文件：

#include"队列顺序存储.h"
#include<string.h>
#include<stdlib.h>
#include<stdio.h>

#define M 8
#define N 3
//数据元素结构体
typedef struct PERSON
{
    char name[64];
    int age;
}Person;

int main()
{
    //创建循环链表
    SeqQueue* queue = Init_SeqQueue();

    //创建数据
    Person p1 = { "aaa",10 };
    Person p2 = { "bbb",20 };
    Person p3 = { "ccc",30 };
    Person p4 = { "ddd",40 };
    Person p5 = { "eee",50 };

    //入队
    Push_SeqQueue(queue, (Person*)&p1);
    Push_SeqQueue(queue, (Person*)&p2);
    Push_SeqQueue(queue, (Person*)&p3);
    Push_SeqQueue(queue, (Person*)&p4);
    Push_SeqQueue(queue, (Person*)&p5);
    
    //返回队首元素
    Person* temp = (Person*)Front_SeqQueue(queue);
    printf("value: %s age: %d
", temp->name, temp->age);

    //出队
    Pop_SeqQueue(queue);
    
    //返回队首元素
    temp = (Person*)Front_SeqQueue(queue);
    printf("value: %s age: %d
", temp->name, temp->age);

    int size = Size_SeqQueue(queue);
    printf("长度%d
", size);

    //清空队列
    Clear_SeqQueue(queue);

    size = Size_SeqQueue(queue);
    printf("长度%d
", size);
    //销毁队列
    Free_SeqQueue(queue);
    return 0;
}

测试结果：