【C语言】数据结构之索引队列

《数据结构之索引队列》

---

基本功能：入队、出队、查询空余
$~$
$~$运行结果：

---

【main.c】

#include "Queue.h"

#define SIZE_QUEUE_TEST 26
#define LEN_TEST_ARRAY  10

u8 TEST[SIZE_QUEUE_TEST][LEN_TEST_ARRAY];   // 静态缓冲区
pQueue mq = NULL;           // 索引队列

int main()
{
    u8 buf1[LEN_TEST_ARRAY]={'\0'};
    u8 buf2[LEN_TEST_ARRAY]={'\0'};
    mq = Queue_Create(SIZE_QUEUE_TEST);

    memset(TEST, 0, sizeof(TEST)/sizeof(TEST[0]));
    memset(buf1, 'A', LEN_TEST_ARRAY);
    memset(buf2, 'B', LEN_TEST_ARRAY);

    Queue_Enqueue(mq, TEST[mq->rear], buf1, LEN_TEST_ARRAY);            // 入队
    Queue_Enqueue(mq, TEST[mq->rear], buf2, LEN_TEST_ARRAY);

    printf("free space: %d \n", Queue_GetFree(mq));                     // 空余空间

    {
        u8 tmp[LEN_TEST_ARRAY];
        Queue_Dequeue(mq, tmp, LEN_TEST_ARRAY);                         // 出队
        printf("free space: %d  data is : ", Queue_GetFree(mq));
        {
            int i=0;
            for(; i<LEN_TEST_ARRAY; i++)
                printf("%c", tmp[i]);
            printf("\n\n");
        }

        Queue_Dequeue(mq, tmp, LEN_TEST_ARRAY);                         // 出队
        printf("free space: %d  data is : ", Queue_GetFree(mq));
        {
            int i=0;
            for(; i<LEN_TEST_ARRAY; i++)
                printf("%c", tmp[i]);
            printf("\n\n");
        }
    }

    Queue_Destory(mq);
    return 0;
}

---

【Queue.c】

#include "Queue.h"

int Queue_Length(pQueue Q)
{
    int Len = -1;
    Len =  Q->rear - Q->front;
    if(Len >= 0) return Len;
    else
        return Q->maxsize + Len;
}

u32 Queue_GetFree(const pQueue const Q)
{
    return Q->maxsize - Queue_Length(Q) - 1;
}

pQueue Queue_Create(unsigned int maxsize)
{
    pQueue Q = (pQueue)malloc(sizeof(Queue));

    if (Q == NULL)
    {
        printf("Queue_Create() failed. \n\r");
        assert(NULL);
    }

    Q->pBase = (u8 **)malloc(maxsize * sizeof(u8));
    if ( Q == NULL )
    {
        printf("Queue_Create() failed. \n\r");
        assert(NULL);
    }

    Q->front=0;         //初始化参数
    Q->rear=0;
    Q->maxsize=maxsize;

    return Q;
}

void Queue_Destory(pQueue Q)
{
    free(Q->pBase);
    free(Q);
}


/**
 * 遍历队列
 */
void Queue_ForEach(pQueue Q)
{
    int i=Q->front;
    while(i%Q->maxsize!=Q->rear)
    {
        printf("------------------------------ i  =  %d ------------------------------ \n\r", i);
        printf("%s \n\r", Q->pBase[i]);
        i++;
    }
}

bool Queue_isFull(pQueue Q)
{
    if(Q->front==(Q->rear+1)%Q->maxsize)    // 判断循环链表是否满，留一个预留空间不用
        return true;
    else
        return false;
}

bool Queue_isEmpty(pQueue Q)
{
    if(Q->front==Q->rear)    // 判断是否为空
        return true;
    else
        return false;
}

bool Queue_Enqueue(pQueue Q, u8* _dst, const u8* const _src, u32 length)
{
    if(Queue_isFull(Q))
        return false;
    else
    {
        Q->pBase[Q->rear] = _dst;
        memset(Q->pBase[Q->rear], 0, length);
        memcpy(Q->pBase[Q->rear], _src, length);
        Q->rear = (Q->rear+1)%Q->maxsize;
        return true;
    }
}

bool Queue_Dequeue(pQueue Q, u8* data_ptr, u32 len)
{

    if(Queue_isEmpty(Q))
    {
        return false;
    }
    else
    {
        memset(data_ptr, 0, len);
        memcpy(data_ptr, Q->pBase[Q->front], len);
        Q->front=(Q->front+1)%Q->maxsize;
        return true;
    }
}

---

【Queue.h】

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <assert.h>

#define u8 unsigned char
#define u32 unsigned int

#define bool u32

#define true 1
#define false 0

typedef struct
{
    unsigned char** pBase;      // 指针数组,用于存放数据的地址
    int front;                  // 指向队列第一个元素
    int rear;                   // 指向队列最后一个元素的下一个元素
    int maxsize;                // 循环队列的最大存储空间
}Queue,*pQueue;

pQueue Queue_Create(unsigned int maxsize);
void Queue_Destory(pQueue Q);
void Queue_ForEach(pQueue Q);
bool Queue_isFull(pQueue Q);
bool Queue_isEmpty(pQueue Q);
bool Queue_Dequeue(pQueue Q, u8* data_ptr, u32 len);
bool Queue_Enqueue(pQueue Q, u8* _dst, const u8* const _src, u32 length);
u32 Queue_GetFree(const pQueue const q);

---

ends…