C循环队列

Love The Way You Lie 2022-08-27 05:40 212阅读 0赞

CirQueue.h

#ifndef CIRQUEUE_H_INCLUDED
    #define CIRQUEUE_H_INCLUDED
    
    #ifndef QElementType
    #define QElementType void *
    #endif
    
    #ifndef MAX_QUEUE_SIZE
    #define MAX_QUEUE_SIZE 10000
    #endif
    
    typedef struct
    {
        QElementType *base;//存储数据
        int front;//指向队列头
        int rear;//指向队列尾
    }Cir_Queue,*P_Cir_Queue;
    
    //初始化循环队列
    long func_long_init_Cir_Queue(P_Cir_Queue *pp_cir_queue);
    
    //销毁队列
    long func_long_destroy_cir_queue(P_Cir_Queue p_cir_queue);
    
    //清空队列
    long func_long_clear_cir_queue(P_Cir_Queue p_cir_queue);
    
    //循环队列是否为空，为空返回1, 非空0, 错误<0
    long func_long_Is_empty_cir_queue(P_Cir_Queue p_cir_queue);
    
    //循环队列是否已满，满则返回1, 未满则返回0, 错误<0
    long func_long_Is_full_cir_queue(P_Cir_Queue p_cir_queue);
    
    //获得队列的大小
    int func_long_get_cir_queue_length(P_Cir_Queue p_cir_queue, unsigned long *p_queue_lenth);
    
    //添加元素到队列，添加成功返回true
    long func_long_insert_cir_queue(P_Cir_Queue p_cir_queue, QElementType element);
    
    //删除元素，值保存在p_element中，删除成功返回0
    long func_long_del_cir_queue(P_Cir_Queue p_cir_queue, QElementType *p_element);
    
    
    #endif // CIRQUEUE_H_INCLUDED

CirQueue.c

#include <stdio.h>
    #include <malloc.h>
    #include <string.h>
    #include "CirQueue.h"
    
    #define debug_printf printf
    //#define debug_printf //
    
    /*循环队列 C语言实现
     *2014-05-08
     *huanglei529@163.com.com
     */
    
    //初始化循环队列
    long func_long_init_Cir_Queue(P_Cir_Queue *pp_cir_queue)
    {
        long long_ret = 0,long_last_ret = 0;
        if(pp_cir_queue == NULL)
        {
            long_ret = -1;
            long_last_ret = -1;
        }
    
        if(long_last_ret == 0)
        {
            *pp_cir_queue = (P_Cir_Queue)malloc(sizeof(Cir_Queue));
            if( (*pp_cir_queue) == NULL)
            {
                long_ret = -2;
                long_last_ret = -1;
            }
        }
        if(long_last_ret == 0)
        {
            (*pp_cir_queue)->base = (QElementType *)malloc(MAX_QUEUE_SIZE*sizeof(QElementType));
            if( !(*pp_cir_queue)->base )
            {
                long_ret = -3;
                long_last_ret = -1;
            }
            else
            {
                memset((*pp_cir_queue)->base,0,MAX_QUEUE_SIZE*sizeof(QElementType));
                //初始条件，空队列
                (*pp_cir_queue)->front = 0;
                (*pp_cir_queue)->rear = 0;
            }
        }
    
        return long_ret;
    }
    
    //销毁队列
    long func_long_destroy_cir_queue(P_Cir_Queue p_cir_queue)
    {
        long long_ret = 0,long_last_ret = 0;
    
        if(!p_cir_queue)
        {
            long_ret = -1;
            long_last_ret = -1;
        }
    
        if(long_last_ret == 0)
        {
            if (p_cir_queue->base)
            {
                free(p_cir_queue->base);
                p_cir_queue->base = NULL;
            }
            p_cir_queue->front = 0;
            p_cir_queue->rear = 0;
        }
    
        return long_ret;
    }
    
    //清空队列
    long func_long_clear_cir_queue(P_Cir_Queue p_cir_queue)
    {
        long  long_ret = 0,long_last_ret = 0;
    
        if( (!p_cir_queue) || (!p_cir_queue->base) )
        {
            long_ret = -1;
            long_last_ret = -1;
        }
    
        if(long_last_ret == 0)
        {
            p_cir_queue->front = 0;
            p_cir_queue->rear  = 0;
        }
    
        return long_ret;
    }
    
    //循环队列是否为空，为空返回1, 非空0, 错误<0
    long func_long_Is_empty_cir_queue(P_Cir_Queue p_cir_queue)
    {
        long long_ret = 0,long_last_ret = 0;
    
        if( (!p_cir_queue) || (!p_cir_queue->base) )
        {
            long_ret = -1;
            long_last_ret = -1;
        }
    
        if(long_last_ret == 0)
        {
            if (p_cir_queue->front == p_cir_queue->rear)
                long_ret = 1;
        }
    
        return long_ret;
    }
    
    //循环队列是否已满，满则返回1, 未满则返回0, 错误<0
    long func_long_Is_full_cir_queue(P_Cir_Queue p_cir_queue)
    {
        long long_ret = 0,long_last_ret = 0;
    
        if( (!p_cir_queue) || (!p_cir_queue->base) )
        {
            long_ret = -1;
            long_last_ret = -1;
        }
    
        if(long_last_ret == 0)
        {
            if ((p_cir_queue->rear+1)%MAX_QUEUE_SIZE == p_cir_queue->front)
                long_ret = 1;
        }
    
        return long_ret;
    }
    
    //获得队列的大小
    int func_long_get_cir_queue_length(P_Cir_Queue p_cir_queue, unsigned long *p_queue_lenth)
    {
        long long_ret = 0,long_last_ret = 0;
    
        if( (!p_cir_queue) || (!p_cir_queue->base) )
        {
            long_ret = -1;
            long_last_ret = -1;
        }
    
        if(long_last_ret == 0)
        {
            *p_queue_lenth = (p_cir_queue->rear - p_cir_queue->front + MAX_QUEUE_SIZE)%MAX_QUEUE_SIZE;
        }
    
        return long_ret;
    }
    
    //添加元素到队列，添加成功返回true
    long func_long_insert_cir_queue(P_Cir_Queue p_cir_queue, QElementType element)
    {
        long long_ret = 0,long_last_ret = 0;
    
        if( (!p_cir_queue) || (!p_cir_queue->base) )
        {
            long_ret = -1;
            long_last_ret = -1;
        }
    
        if(long_last_ret == 0)
        {
            //判断队列是否已满
            if ( func_long_Is_full_cir_queue(p_cir_queue) == 1 )
            {
                long_ret = -2;
                long_last_ret = -1;
            }
        }
        if(long_last_ret == 0)
        {
            p_cir_queue->base[p_cir_queue->rear] = (QElementType)malloc(strlen(element)+1);
            if( !p_cir_queue->base[p_cir_queue->rear] )
            {
                long_ret = -3;
                long_last_ret = -1;
            }
            else
            {
                memset(p_cir_queue->base[p_cir_queue->rear], 0, strlen(element)+1);
                memcpy(p_cir_queue->base[p_cir_queue->rear], element, strlen(element));
                p_cir_queue->rear = (p_cir_queue->rear + 1) % MAX_QUEUE_SIZE;
            }
        }
    
        return long_ret;
    }
    
    //删除元素，值保存在p_element中，删除成功返回0
    long func_long_del_cir_queue(P_Cir_Queue p_cir_queue, QElementType *p_element)
    {
        long long_ret = 0,long_last_ret = 0;
    
        if( (!p_cir_queue) || (!p_cir_queue->base) )
        {
            long_ret = -1;
            long_last_ret = -1;
        }
    
        if(long_last_ret == 0)
        {
            //判断队列是否为空
            if ( func_long_Is_empty_cir_queue(p_cir_queue) == 1 )
            {
                long_ret = -2;
                long_last_ret = -1;
            }
        }
    
        if(long_last_ret == 0)
        {
            //*p_element = p_cir_queue->base[p_cir_queue->front];
            strncpy(*p_element, p_cir_queue->base[p_cir_queue->front], strlen(p_cir_queue->base[p_cir_queue->front])+1);
            p_cir_queue->front = (p_cir_queue->front + 1) % MAX_QUEUE_SIZE;
        }
    
        return long_ret;
    }
    
    //打印队列
    void func_void_print_cir_queue(P_Cir_Queue p_cir_queue)
    {
        long long_last_ret = 0;
        if ( (!p_cir_queue) || (!p_cir_queue->base) )
        {
            long_last_ret = -1;
            debug_printf("the Queue is NULL!\n");
        }
        if( long_last_ret == 0)
        {
            if ( func_long_Is_empty_cir_queue(p_cir_queue) == 1)
            {
                long_last_ret = -2;
                debug_printf("the Queue is empty!\n");
            }
        }
    
        if( long_last_ret == 0)
        {
            debug_printf("the Queue is:\n");
            int i = p_cir_queue->front;
            while (i != p_cir_queue->rear)
            {
                debug_printf("%s \n",p_cir_queue->base[i]);
                i = (i+1)%MAX_QUEUE_SIZE;
            }
        }
    }
    
    void func_void_test_cir_queue()
    {
        long long_last_ret = 0;
        P_Cir_Queue p_cir_queue = NULL;
        QElementType element = (QElementType)malloc(200);
    
        if( func_long_init_Cir_Queue(&p_cir_queue) != 0 )
        {
            long_last_ret = -1;
        }
        if( long_last_ret == 0 )
        {
            func_long_insert_cir_queue( p_cir_queue, "kaka");
            func_long_insert_cir_queue( p_cir_queue, "2");
            func_long_insert_cir_queue( p_cir_queue, "3");
            func_long_insert_cir_queue( p_cir_queue, "4");
            func_long_insert_cir_queue( p_cir_queue, "5");
            func_long_insert_cir_queue( p_cir_queue, "6");
            func_void_print_cir_queue(p_cir_queue);
            if (func_long_del_cir_queue(p_cir_queue, &element) == 0)
            {
                debug_printf("del data is %s:\n",element);
            }
            func_void_print_cir_queue(p_cir_queue);
            //func_long_destroy_cir_queue(p_cir_queue);
            debug_printf("clear queue\n");
            func_long_clear_cir_queue( p_cir_queue);
            func_long_insert_cir_queue( p_cir_queue, "7");
            func_void_print_cir_queue(p_cir_queue);
            free(element);
        }
    }
    
    /*
    int main(int argc, char *argv[])
    {
        //测试
        func_void_test_cir_queue();
        return 0;
    }
    */