环形队列c语言代码

这段代码实现了一个环形队列，数据类型可以根据自己的需要更改，这里预留的是指针类型。

ring_queue.h

#ifndef _RINGQUEUE_
#define _RINGQUEUE_

#include <stdbool.h>
#include <stdio.h>
#include <string.h>

// 队列包含的信息
typedef struct queue
{
    char **qu;      //用来存储全部的队列中的元素
    int head;     //队列头
    int tail;     //队尾
    int qlength;  //队列长度
    int maxsize;  //用来记录队列的最大容量

}RQUEUE;

RQUEUE  *rq_init ( RQUEUE *q, char **qu, int maxsize );
bool rq_full (RQUEUE *q);
bool rq_empty(RQUEUE *q);
bool rq_front(RQUEUE *q, char **data);
bool rq_back (RQUEUE *q, char **data);
bool rq_push (RQUEUE *q, char *data);
bool rq_pop  (RQUEUE *q, char **data);
int rq_size  (RQUEUE *q);
//------------------
void rq_traverse(RQUEUE *q);

#endif

ring_queue.c

#include "ring_queue.h"

#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
#define  RQMAXSIZE  5
#define  DMAXSIZE  8
//  初始化队列
RQUEUE  *rq_init ( RQUEUE *q, char **qu, int maxsize )
{
    printf("rq_init\tin[%lu]\n",sizeof(RQUEUE));

    if (q == NULL) {
        printf("Memory alloc failure\n");
        return(NULL);
    }

	q->qu = qu;
    if(NULL==q->qu)
    {
        printf("Memory allocation failure");
        return(NULL);        //退出程序
    }
    //分配完空间后，1开始队头队尾都在一起，因为没人，都为0长度也为0，
    q->head = 0;
    q->tail = 0;
    q->qlength = 0;
    q->maxsize = maxsize;

	printf("rq_init\tout\n");
    return q;
}

// 判断空队列，长度为0则为空
bool rq_empty (RQUEUE *q)
{
    return  q->qlength == 0 ? true : false;
}

// 判断满队列，长度=最大容量为满
bool rq_full (RQUEUE *q)
{
    return q->qlength == q->maxsize ? true : false;
}

//入队
bool rq_push (RQUEUE *q, char *data)
{
	printf("rq_push in %s\n", data);
    // 队列不满才插入
    if (rq_full(q)) {
        printf("队列满了，插入失败\n");
        return false;

    }else{
        //给队伍最尾添加赋值。
        //q->qu[q->tail] = num;
		printf("%d \n",  q->tail);
		char (*p)[DMAXSIZE] = (char(*)[DMAXSIZE])q->qu;
		memcpy(p[q->tail], data, DMAXSIZE);
        //队尾向后移动一位，如果超过最大值，则从0开始，变成队尾
        q->tail = (q->tail +1)%q->maxsize;
        //队伍长度+1
        q->qlength++;
		printf("rq_push\tout\n");
        return true;
    }

}

// 出队
bool rq_pop (RQUEUE *q, char **data)
{
	printf("rq_pop\tin\n");
    // 队列有元素才能够删除
    if (rq_empty(q)) {
        printf("队列为空，删除失败\n");
        return false;
    }else{
		char (*p)[DMAXSIZE] = (char(*)[DMAXSIZE])q->qu;
		*data = p[(q->head)];
        //队头向后移动一位 超过最大值又重新 从0 开始计算
        q->head = (q->head +1)%q->maxsize;
		
        // 队伍长度-1
        q->qlength--;
		printf("rq_pop\tout\n");
        return true;
    }
}

//队列已有数据
int rq_size(RQUEUE *q)
{
	return q->qlength;
}

//队列中头元素
bool rq_front(RQUEUE *q, char **data)
{
	printf("rq_front\tin\n");
    // 队列有元素才能够删除
    if (rq_empty(q)) {
        printf("队列为空，查询失败\n");
        return false;
    }else{
		char (*p)[DMAXSIZE] = (char(*)[DMAXSIZE])q->qu;
		*data = p[(q->head)];
		printf("rq_front\tout\n");
        return true;
    }
}

//队列中尾元素
bool rq_back (RQUEUE *q, char **data)
{
	printf("rq_back\tin\n");
    // 队列有元素才能够删除
    if (rq_empty(q)) {
        printf("队列为空，查询失败\n");
        return false;
    }else{
		char (*p)[DMAXSIZE] = (char(*)[DMAXSIZE])q->qu;
		*data = p[(q->tail+q->maxsize-1)%q->maxsize];
		printf("rq_back\tout\n");
        return true;
    }
}

// 遍历队列元素
void rq_traverse(RQUEUE *q)
{
	printf("rq_traverse\tin\n");
	char (*p)[DMAXSIZE] = (char(*)[DMAXSIZE])q->qu;
    // 在队列长度范围内 打印队列从队列头 到队列尾的元素
    for (int i=0 ; i<q->qlength; i++) {
      printf("%s ",  p[(q->head+i)%q->maxsize]);
    }
    printf("\n");
	printf("rq_traverse\tout\n");
}

int main(int argc, const char * argv[]) {
    // insert code here...
	printf("main\tin\n");

	RQUEUE Q;
	char a[RQMAXSIZE][DMAXSIZE];
	printf("%ld\n", ARRAY_SIZE(a));
    rq_init(&Q, (char **)a, ARRAY_SIZE(a));
    if ( rq_empty(&Q)) {
        printf("空队列\n");
    };

	char *c = NULL;
	rq_front(&Q, &c);
	printf("%s \n",  c);
	rq_back (&Q, &c);
	printf("%s \n",  c);
	
	char *aa = "1111111";

    rq_push(&Q, aa);
	aa = "2222222";
    rq_push(&Q, aa);
	aa = "3333333";
    rq_push(&Q, aa);
    if ( rq_empty(&Q)) {
        printf("空队列\n");
    };

	rq_front(&Q, &c);
	printf("%s \n",  c);
	rq_back (&Q, &c);
	printf("%s \n",  c);
	aa = "444444";
    rq_push(&Q, aa);
	aa = "555555";
    rq_push(&Q, aa);


    rq_pop(&Q, &c);
	printf("rq_pop = %s \n",  c);
	aa = "666666";
    rq_push(&Q, aa);
	aa = "77777";
	rq_push(&Q, aa);

    if (rq_full(&Q)) {
        printf("满队列\n");
    }

    rq_traverse(&Q);
	
	rq_front(&Q, &c);
	printf("%s \n",  c);
	rq_back (&Q, &c);
	printf("%s \n",  c);

    return 0;
}

编译查看运行结果gcc ring_queue.c -o ring_q

rt@ubuntu:~/ring_queue$ ./ring_q
main	in
5
rq_init	in[20]
rq_init	out
空队列
rq_front	in
队列为空，查询失败
(null) 
rq_back	in
队列为空，查询失败
(null) 
rq_push in 1111111
0 
rq_push	out
rq_push in 2222222
1 
rq_push	out
rq_push in 3333333
2 
rq_push	out
rq_front	in
rq_front	out
1111111 
rq_back	in
rq_back	out
3333333 
rq_push in 444444
3 
rq_push	out
rq_push in 555555
4 
rq_push	out
rq_pop	in
rq_pop	out
rq_pop = 1111111 
rq_push in 666666
0 
rq_push	out
rq_push in 77777
队列满了，插入失败
满队列
rq_traverse	in
2222222 3333333 444444 555555 666666 
rq_traverse	out
rq_front	in
rq_front	out
2222222 
rq_back	in
rq_back	out
666666