C循环队列

最新推荐文章于 2022-05-18 00:05:38 发布
最新推荐文章于 2022-05-18 00:05:38 发布
阅读量1k 收藏
点赞数
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/B_H_L/article/details/25627963
版权

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;
}
*/


B_H_L
关注
专栏目录
使用linux中标准的queue.h头文件插件链表，队列，循环队列
u010758403的专栏
09-07 4546
#include #include #include #include int test_list() {     LIST_HEAD(listhead, entry) head;     struct listhead *headp;                 /* List head. */     struct entry {         ch
循环队列详解
qq_31186123的博客
10-07 2526
前面分析顺序队的时候,我们知道,顺序队存在”假溢出”的问题,这个问题有时会造成很大的内存浪费,循环队列就是为了解决这个问题而提出地一个很巧妙的办法.循环队列和顺序队列的主要区别在于:循环队列将顺序队列臆造成一个环状空间.在操作上这种异同体现在: 相同点: 在顺序队列和循环队列中,进行出队、入队操作时,队首、队尾指针都要加 1 ,朝前移动。 不同点: 1. 在循环队列中当队首、队尾指针指向向...
循环队列——队列的顺序表示和实现
林贻民的博客
08-14 5660
前面分析顺序队的时候,我们知道,顺序队存在”假溢出”的问题,这个问题有时会造成很大的内存浪费,循环队列就是为了解决这个问题而提出地一个很巧妙的办法.循环队列和顺序队列的主要区别在于:循环队列将顺序队列臆造成一个环状空间.在操作上这种异同体现在: 相同点:在顺序队列和循环队列中,进行出队、入队操作时,队首、队尾指针都要加 1 ,朝前移动。 不同点: 1. 在循环队列中当队首、队尾指针指
c语言：循环队列
cmustard的博客
09-26 673
1.在循环队列中需要设置队头，队尾两个指针，并且约定；队头指针front指向队头元素的前一个位置，队尾指针rear指向队尾元素。队列的这种头尾相接的顺序存储结构称为循环队列。 2.在循环队列中有个很重要的问题就是：队空和队满的判定问题。在循环队列中队空和队满的判定条件都可以是front=rear。因此，我们需要浪费一个数组元素空间，让队满的条件变为:(rear+1)%QueueSize=fron
循环队列（C语言）
qq_48757526的博客
05-18 2592
循环队列里需要注意的是每次头指针和尾指针的位置，因为是循环队列，所以每次入队，头指针和尾指针都会+1，但是每次出队，只有尾指针-1，当头指针与尾指针相遇的时候，表示这个队列已经是空的了，我们可以利用这个来判空。 头文件函数声明 #define MAX_SIZE 100 typedef int ELEM_TYPE; typedef struct Queue { ELEM_TYPE* base;//接受malloc 申请的空间 int front;//表头指针 int rear;//表尾指针 //
C语言循环队列
11-09
C语言实现循环对列，思路清晰。编译环境VC 2008下可编译通过。
C语言循环队列的表示与实现实例详解
01-01
循环队列可以更简单的防止伪溢出的发生，但是队列大小是固定的。 2.实例代码： /* 队列的顺序存储结构(循环队列) */ #define MAX_QSIZE 5 /* 最大队列长度+1 */ typedef struct { QElemType *base; /* 初始化的...
C语言循环队列的代码实现
06-17
在C语言中，我们可以用结构体来定义一个循环队列，包括队列的容量、当前头指针和尾指针以及存储元素的数组。 `SeqQueue.c` 文件通常会包含循环队列的初始化、入队、出队、判断队列是否为空和满等操作的函数实现。...
c语言 循环队列
07-11
在C语言中实现循环队列，我们需要定义一个数组来存储元素，同时维护两个指针——front（队首）和rear（队尾）。front指向队列中的第一个元素，而rear指向下一个要加入元素的位置。当rear追上front时，队列满了；当...
libcurl源码编译及使用
热门推荐
B_H_L的专栏
02-26 3万+
1：源码编译 libcurl 7.21以后的版本在Windows下的编译比较简单，自带了MinGW和VC环境的Makefile文件，首先去Curl官网下载源代码：http://curl.haxx.se/download.html，任选一个下载即可，推荐这个： curl-7.21.2.tar.gz，下载完成后解压开，打开命令行进入curl源码目录，(在此之前请先设置好MinGW的环境变量)：
轻量级C语言实现的xml解析库minixml
B_H_L的专栏
12-01 1万+
1下载：http://www.msweet.org/downloads.php?L+Z3 2说明：Mini-XML是一个小型的开源的XML解析器，采用 C 语言开发。该解析器最大的特点就是小型、无须依赖其他类库，只需要 GCC 编译器 和 make 程序即可编译，支持 UTF-8/UTF-16 编码。 Mini-XML支持读取UTF-8和UTF-16和UTF-8编码的XML文件和字
C无符号数和有符号数探讨
B_H_L的专栏
08-23 4797
C 、C++都支持有符号（默认）和无符号数，java只支持有符号数。 整数表示：无符号整数：无符号编码                      有符号数：补码（范围不对称），| TMIN |=| TMAX |+1 C语言标准并没有要求用补码形式来表示有符号数，但是几乎所有的机器都是这么做的 C标准只规定了每种数据类型必须能够表示的最小的取值范围而不是确定范围。long long是ISO
C一个简单的通配符匹配实例
B_H_L的专栏
08-18 4039
通配符是用来通配的，不同的系统上通配符不一样， 例如：SQL中有“_”通配符（仅替代一个字符） 与“%”通配符（替代一个或多个字符），须与LINK运算符一起使用。 此处仅考虑通配符*和？，*表示0或任意多个字符，？表示单个字符。 int match(char *pat,char *str) { switch(*pat){ case ‘\0’   return !*str;
win32下使用pthread
B_H_L的专栏
06-20 3041
pthread下载地址:ftp://sourceware.org/pub/pthreads-win32
C 关于C中布尔类型的总结
B_H_L的专栏
08-16 2233
c语言没有正式的、内建的布尔类型，一般用整数表示布尔值,只不过其范围大大缩小了，部分原因在于选择一个这样的类型涉及最好由程序员来决定的空间和时间中，使用int可能更快，选择char可能更节省空间。 c语言将0值解释为假，而将任何非0值解释为真，ANSI规定关系和逻辑操作符==、！=、、>=、 通常自定义的布尔型形式： #define TRUE 1 #define FALSE 0 type
C有序链表的终极插入函数
B_H_L的专栏
07-13 1851
版本1、2、3未像有些数据库结构书上推荐在链表前添加一个“头结点”（哑节点:始终是链表的第一个节点，只是不存储有用数据）这样就消除插入链表起始位置这个特殊情况。 版本1:保持一个previous指针和一个current指针，传递的参数是根指针，在链表起始位置插入时（特殊情况），不能修改根指针 #include #include #define FALSE 0 #de
Computer.Systems.A.Programmers.Perspective笔记
B_H_L的专栏
07-10 1289
#include int main() { printf("hello, world\n"); } unix> gcc -o hello hello.c，gcc编译器编译流程：                                                            Figure: The compilation system Here, the
基于大模型技术的算力产业监测服务平台设计
最新发布
09-17
内容概要：本文提出了一种新型算力产业监测服务平台的设计理念，运用国内自主研发的大模型技术支持，通过对传统技术的改进和完善，提出了三层架构的设计方法，即基础设施层（含向量数据库和模型训练）、大模型应用框架层（强化数据处理与多维关系挖掘）及业务层（如智能分析助手）。这种设计方案旨在提高算力产业发展监测与决策制定的质量。 适合人群：电信行业的从业人员及研究人员；算力产业链各环节管理者；政府相关机构和政策决策者。 使用场景及目标：在多种算力相关的应用场景（如云计算中心管理，数据中心监测，政策分析）中辅助决策者进行快速有效的信息获取和技术选择；助力算力产业发展方向的精确把控和战略调整。 其他说明：随着大模型技术的日臻成熟，该算力产业监测服务平台预计将进一步丰富自身的应用领域和服务深度，以促进算力行业更智慧化发展。
c语言循环队列
05-24
下面是一个基于数组实现的循环队列的C语言代码： ```c #define MAXSIZE 100 typedef struct { int data[MAXSIZE]; int front; // 队头指针，指向队头元素 int rear; // 队尾指针，指向队尾元素的下一个位置 } ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值