循环队列的c语言实现

一、什么是循环队列
    1、基本概念
    队列就是一个能够实现“先进先出”的存储结构，队列分为链式队列和静态队列。静态队列一般用数组来实现，但此时的队列必须是循环队列，否则会造成巨大的内存浪费；链式队列是用链表来实现队列的。说白了循环队列就是一个数组，我们把这个数组当成首尾相连来使用(写到数组的末尾后从头开始写)。

    2、结构体

typedef  char  Item; //环形队列的数据类型,根据自身情况设置

typedef struct queue   
{   
    Item *data;             //使用指针的方式，大小在使用循环队列的文件分配，减少queue.c、queue.h和其他文件的耦合性！
    unsigned int front;     //指向队列第一个元素  
    unsigned int rear;      //指向队列最后一个元素的下一个元素  
    unsigned int maxsize;   //循环队列的最大存储空间  
}QUEUE, *PQUEUE;

    说明：
    a、队列初始化时，front和rear值都为零。
    b、当队列为空时，front与rear的值相等，但不一定为零。
    c、当队列不为空时，front指向队列的第一个元素，rear指向队列最后一个元素的下一个位置。

二、队列的基本操作
    1、判断队列是否为空。若front与rear的值相等（不一定为零）则队列为空。

    2、判断队列是否填满。这个问题比较复杂，如下图所示（此图转载），假设数组的存数空间为7，此时已经存放1，a，5,7,22,90六个元素了，如果在往数组中添加一个元素，则rear=front；此时，队列满与队列空的判断条件front=rear相同，这样的话我们就不能判断队列到底是空还是是满了。解决这个问题有两个办法：一是增加一个参数，用来记录数组中当前元素的个数；第二个办法是，少用一个存储空间，也就是数组的最后一个存数空间不用，当（rear+1）%maxsiz=front时，队列满。

   

    3、循环队列入队
        （1）把值存在rear所在的位置；
        （2）rear=（rear+1）%maxsize ，其中maxsize代表数组的长度；
    4、循环队列出队
        （1）先保存出队的值；
        （2）front=（front+1）%maxsize ，其中maxsize代表数组的长度；
    

三、例子。

        这个简单的例子只是为了演示循环队列的使用而已，先把数据放入循环队列，然后取出打印出来。

        main.c文件

#include <stdio.h>
#include "queue.h"

#if 0
#define PrintToBuffer(fmt, args...) do {                      \
    if(!FullQueue(&queue)) {                                  \
        sprintf(printk_buffer.high[queue.rear],fmt, ## args); \
        Enqueue(&queue,0);                                    \
    }                                                         \
}while(0)    

#define PrintToConsole() do {                                 \
    if(!EmptyQueue(&queue)) {                                 \
        printk("%s",printk_buffer.high[queue.front]);         \
        Dequeue(&queue,0);                                    \
    }                                                         \
}while(0)
#endif

#define QUEUE_SIZE  10


QUEUE queue;

int main(int argc, char **argv)
{
    int count = 0;
    Item value = 'a';
    
    CreateQueue(&queue, QUEUE_SIZE);
    
    for(count = 0; count < 8; count++) {
        Enqueue(&queue, value);
        value++;
    }   
    
    for(count = 0; count < 8; count++) {
        Dequeue(&queue, &value);
        printf("%c ", value);
    }
    printf("\n");
    
    return 0;
}

        queue.c文件

#include <stdio.h>
#include <stdlib.h>
#include "queue.h"
    
void CreateQueue(PQUEUE Q,int maxsize)  
{        
    Q->data = (Item *)malloc(sizeof(Item) * maxsize);
    Q->front = 0;                              
    Q->rear = 0;  
    Q->maxsize = maxsize; 
    
    return;     
} 

bool FullQueue(PQUEUE Q)  
{  
    if(Q->front==(Q->rear+1)%Q->maxsize) {     
        return 1;
    } else { 
        return 0;
    }  
} 
 
bool EmptyQueue(PQUEUE Q)  
{  
    if(Q->front==Q->rear) {                   
        return 1;  
    } else {
        return 0;  
    }
}  

bool Enqueue(PQUEUE Q, Item val)  
{  
    if(FullQueue(Q)) {  
        return 0; 
    } else {  
        Q->data[Q->rear] = val;  
        Q->rear = (Q->rear+1)%Q->maxsize;  
        return 1;  
    }      
}  
  
bool Dequeue(PQUEUE Q, Item *val)  
{  
    if(EmptyQueue(Q)) {  
        return 0;  
    } else {  
        *val = Q->data[Q->front];  
        Q->front = (Q->front+1)%Q->maxsize;  
        return 1;  
    }  
} 

        queue.h文件

#ifndef _QUEUE_H_
#define _QUEUE_H_

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

typedef  char  Item; //环形队列的数据类型,根据自身情况设置

typedef struct queue   
{   
    Item *data;             //使用指针的方式，大小在使用循环队列的文件分配，减少queue.c、queue.h和其他文件的耦合性！
    unsigned int front;     //指向队列第一个元素  
    unsigned int rear;      //指向队列最后一个元素的下一个元素  
    unsigned int maxsize;   //循环队列的最大存储空间  
}QUEUE, *PQUEUE;

//分配数据空间和初始化参数 
void CreateQueue(PQUEUE Q,int maxsize);

//判断循环队列是否满，留一个预留空间不用 
bool FullQueue(PQUEUE Q);

//判断循环队列是否空 
bool EmptyQueue(PQUEUE Q);

//将数据放入队列保存
bool Enqueue(PQUEUE Q, Item val);

//从队列取出数据到val
bool Dequeue(PQUEUE Q, Item *val);

#endif

        Makefile文件

CC       = gcc
WORKDIR  = 
INCLUDES = 
LIBS     =
LINKS    =
TARGET   = queuetest

src=$(wildcard *.c ./callback/*.c)
C_OBJS=$(patsubst %.c, %.o,$(src))
#C_OBJS=$(dir:%.c=%.o)

compile:$(TARGET)
	
$(C_OBJS):%.o:%.c
	$(CC) $(CFLAGS) $(INCLUDES) -o $*.o -c $*.c
	
$(TARGET):$(C_OBJS)
	$(CC) -o $(TARGET) $^ $(LIBS) $(LINKS) 

	@echo 
	@echo Project has been successfully compiled.
	@echo
	
install: $(TARGET)
	cp $(TARGET) $(INSTALL_PATH)

uninstall:
	rm -f $(INSTALL_PATH)/$(TARGET)

rebuild: clean compile

clean:
	rm -rf *.o  $(TARGET) *.log *~

四、为什么要使用循环队列

    1、为了缓冲数据。比如，某一时间cpu太忙，收到的数据来不及处理了，这时候就可以把数据先存到循环队列，等cpu不忙了再拿出来处理。