队列的顺序存储框架

队列的定义

　　队列是只允许在一端进行插入操作，另一端进行删除操作的线性表。

　　队列是一种先进先出（FIST IN FIRST OUT）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为对头。

队列的顺序存储框架搭建

顺序列队结构体

typedef struct SEQQUEUE {
    void* data[MAX_SIZE];
    int size;
}SeqQueue;

框架搭建

//初始化
SeqQueue* Init_SeqQueue();
//入队
void Push_SeqQueue(SeqQueue* queue, void* data);
//返回队头元素
void* Front_SeqQueue(SeqQueue* queue);
//出队
void Pop_SeqQueue(SeqQueue* queue);
//返回队尾元素
void* Back_SeuQueue(SeqQueue* queue);
//返回大小
int Size_SeqQueue(SeqQueue* queue);
//清空队列
void Clear_SeqQueue(SeqQueue* queue);
//销毁队
void FreeSpace_SeqQueue(SeqQueue* queue);

队列的顺序存储框架实现 

初始化

SeqQueue* Init_SeqQueue()
{
    SeqQueue* queue = (SeqQueue*)malloc(sizeof(SeqQueue));
    for (int i = 0; i < MAX_SIZE; i++)
        queue->data[i] = NULL;
    queue->size = 0;
    return queue;
}

入队

void Push_SeqQueue(SeqQueue* queue, void* data)
{
    //数组的左边（开始位置）当做队头
    if (queue == NULL)
        return;
    if (data == NULL)
        return;
    if (queue->size == MAX_SIZE)
        return;
    queue->data[queue->size] = data;
    queue->size++;
}

返回队头元素

void* Front_SeqQueue(SeqQueue* queue)
{
    if (queue == NULL)
        return NULL;
    if (queue->size == 0)
        return NULL;
    return queue->data[0];
}

出队

void Pop_SeqQueue(SeqQueue* queue)
{
    if (queue == NULL)
        return ;
    if (queue->size == 0)
        return ;
    for (int i = 0; i < queue->size - 1; i++)
        queue->data[i] = queue->data[i + 1];

    queue->size--;
}

返回队尾元素

void* Back_SeuQueue(SeqQueue* queue)
{
    if (queue == NULL)
        return NULL;
    if (queue->size == 0)
        return NULL;
    return queue->data[queue->size-1];
}

返回大小

int Size_SeqQueue(SeqQueue* queue)
{
    if (queue == NULL)
        return -1;
    return queue->size;
}

清空队列

void Clear_SeqQueue(SeqQueue* queue)
{
    if (queue == NULL)
        return ;

    queue->size = 0;
}

销毁队

void FreeSpace_SeqQueue(SeqQueue* queue)
{
    if (queue == NULL)
        return;
    free(queue);
}

队列的顺序存储框架测试

测试思路

    //创建对列
    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, &p1);
    Push_SeqQueue(queue, &p2);
    Push_SeqQueue(queue, &p3);
    Push_SeqQueue(queue, &p4);
    Push_SeqQueue(queue, &p5);

    //输出队尾元素
    Person* b = (Person*)Back_SeuQueue(queue);
    printf("Name:%s Age:%d\n\n", b->name, b->age);

    //输出队列
    while (Size_SeqQueue(queue) > 0)
    {
        //取出队头元素
        Person* p = (Person*)Front_SeqQueue(queue);
        printf("Name:%s Age:%d\n", p->name, p->age);
        //从队头弹出元素
        Pop_SeqQueue(queue);
    }

    //销毁队列
    FreeSpace_SeqQueue(queue);

运行结果

源码

SeqQueue.h

 1 #pragma once
 2 #include<stdio.h>
 3 #include<stdlib.h>
 4 
 5 #define MAX_SIZE 1024
 6 //顺序列队结构体
 7 typedef struct SEQQUEUE {
 8     void* data[MAX_SIZE];
 9     int size;
10 }SeqQueue;
11 
12 //初始化
13 SeqQueue* Init_SeqQueue();
14 //入队
15 void Push_SeqQueue(SeqQueue* queue, void* data);
16 //返回队头元素
17 void* Front_SeqQueue(SeqQueue* queue);
18 //出队
19 void Pop_SeqQueue(SeqQueue* queue);
20 //返回队尾元素
21 void* Back_SeuQueue(SeqQueue* queue);
22 //返回大小
23 int Size_SeqQueue(SeqQueue* queue);
24 //清空队列
25 void Clear_SeqQueue(SeqQueue* queue);
26 //销毁队
27 void FreeSpace_SeqQueue(SeqQueue* queue);

SeqQueue.c

 1 #include"SeqQueue.h"
 2 
 3 //初始化
 4 SeqQueue* Init_SeqQueue()
 5 {
 6     SeqQueue* queue = (SeqQueue*)malloc(sizeof(SeqQueue));
 7     for (int i = 0; i < MAX_SIZE; i++)
 8         queue->data[i] = NULL;
 9     queue->size = 0;
10     return queue;
11 }
12 //入队
13 void Push_SeqQueue(SeqQueue* queue, void* data)
14 {
15     //数组的左边（开始位置）当做队头
16     if (queue == NULL)
17         return;
18     if (data == NULL)
19         return;
20     if (queue->size == MAX_SIZE)
21         return;
22     queue->data[queue->size] = data;
23     queue->size++;
24 }
25 //返回队头元素
26 void* Front_SeqQueue(SeqQueue* queue)
27 {
28     if (queue == NULL)
29         return NULL;
30     if (queue->size == 0)
31         return NULL;
32     return queue->data[0];
33 }
34 //出队
35 void Pop_SeqQueue(SeqQueue* queue)
36 {
37     if (queue == NULL)
38         return ;
39     if (queue->size == 0)
40         return ;
41     for (int i = 0; i < queue->size - 1; i++)
42         queue->data[i] = queue->data[i + 1];
43 
44     queue->size--;
45 }
46 //返回队尾元素
47 void* Back_SeuQueue(SeqQueue* queue)
48 {
49     if (queue == NULL)
50         return NULL;
51     if (queue->size == 0)
52         return NULL;
53     return queue->data[queue->size-1];
54 }
55 //返回大小
56 int Size_SeqQueue(SeqQueue* queue)
57 {
58     if (queue == NULL)
59         return -1;
60     return queue->size;
61 }
62 //清空队列
63 void Clear_SeqQueue(SeqQueue* queue)
64 {
65     if (queue == NULL)
66         return ;
67 
68     queue->size = 0;
69 }
70 //销毁队
71 void FreeSpace_SeqQueue(SeqQueue* queue)
72 {
73     if (queue == NULL)
74         return;
75     free(queue);
76 }

main.c

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdlib.h>
 4 #include<stdio.h>
 5 #include<string.h>
 6 #include"SeqQueue.h"
 7 
 8 //Person类型结构体
 9 typedef struct PERSON {
10     char name[64];
11     int age;
12 }Person;
13 
14 int main()
15 {
16     //创建对列
17     SeqQueue* queue = Init_SeqQueue();
18 
19     //创建数据
20     Person p1 = { "aaa",10 };
21     Person p2 = { "bbb",20 };
22     Person p3 = { "ccc",30 };
23     Person p4 = { "ddd",40 };
24     Person p5 = { "eee",50 };
25 
26     //数据入队列
27     Push_SeqQueue(queue, &p1);
28     Push_SeqQueue(queue, &p2);
29     Push_SeqQueue(queue, &p3);
30     Push_SeqQueue(queue, &p4);
31     Push_SeqQueue(queue, &p5);
32 
33     //输出队尾元素
34     Person* b = (Person*)Back_SeuQueue(queue);
35     printf("Name:%s Age:%d\n\n", b->name, b->age);
36 
37     //输出队列
38     while (Size_SeqQueue(queue) > 0)
39     {
40         //取出队头元素
41         Person* p = (Person*)Front_SeqQueue(queue);
42         printf("Name:%s Age:%d\n", p->name, p->age);
43         //从队头弹出元素
44         Pop_SeqQueue(queue);
45     }
46 
47     //销毁队列
48     FreeSpace_SeqQueue(queue);
49 
50     return 0;
51 }