通用循环队列的实现

通用循环队列，这儿是我的笔记，希望大家可以友好交流！！谢谢#__#

有好几天没写了，一直和朋友玩，都没空看了。

今天得空写了一下队列的实现，还是和之前一样，有链表的方式和数组的方式两种。

先是数组的形式吧，队列结构：

struct XHqueue{    int capacity;//由用户来定义容量大小    int len_queue;    int front;    int rear;    OPERATE callback;    void ** data;};

队列一般实现为循环的，即有固定大小的，可以节省空间。这里仍然像实现栈那样，先动态分配一片固定大小的空间给队列。

数组式的实现接口如下：

#include<stdlib.h>#include<stdio.h>#include<memory.h>typedef (*OPERATE)();typedef enum{    false = 0,    true,}bool;struct XHqueue;typedef struct XHqueue XHQUEUE;typedef struct XHqueue* XHQUEUE_T;XHQUEUE_T Queue_Init(XHQUEUE_T Que,int N);bool Queue_IsEmpty(const XHQUEUE_T Que);bool Queue_IsFull(const XHQUEUE_T);void* Queue_Front(const XHQUEUE_T Que);//直插询bool Queue_DeQueue(XHQUEUE_T Que, OPERATE op, void** data);bool Queue_EnQueue(XHQUEUE_T Que,void* data);bool Queue_DeleteAll(XHQUEUE_T Que,OPERATE op, void** data);int Queue_GetCapacity(XHQUEUE_T Que);int Queue_GetLen(XHQUEUE_T Que);#endif 

XHQUEUE_T Queue_Init(XHQUEUE_T Que,int N);
队列初始化时将front指向0，rear指向-1，因为每次入列前rear先加1；
bool Queue_IsEmpty(const XHQUEUE_T Que);
判空函数，判断标志由len是否为0（因为每次入列是len+1,出列时len-1）
bool Queue_IsFull(const XHQUEUE_T);
判满函数，capacity和len是否相等
void* Queue_Front(const XHQUEUE_T Que);
只查询队首元素
bool Queue_DeQueue(XHQUEUE_T Que, OPERATE op, void** data);
出队列函数，其实就是front+1;
bool Queue_EnQueue(XHQUEUE_T Que,void* data);
入队函数
bool Queue_DeleteAll(XHQUEUE_T Que,OPERATE op, void** data);
删除整个队列，包括队列结构
int Queue_GetCapacity(XHQUEUE_T Que);
int Queue_GetLen(XHQUEUE_T Que);

接着实现的接口

#include"tongyongxunhuanduilie.h"struct XHqueue{    int capacity;//由用户来定义    int len_queue;    int front;    int rear;    OPERATE callback;    void ** data;};XHQUEUE_T Queue_Init(XHQUEUE_T Que,int N){    Que = (XHQUEUE_T)malloc(sizeof(XHQUEUE));    if(Que == NULL) return NULL;    Que->data = (void**)malloc(sizeof(void*)*N);    if(Que->data==NULL)    {        free(Que);        return NULL;    }    else    {        Que->capacity = N;        Que->len_queue = 0;        Que->front = 0;        Que->rear = -1;        Que->callback = NULL;        return Que;    }}bool Queue_IsEmpty(const XHQUEUE_T Que){    if(Que == NULL) exit(0);    return Que->len_queue == 0 ? true : false;}bool Queue_IsFull(const XHQUEUE_T Que){    /**因为入队就+1，出队就减1，所以用size来*/    return Que->len_queue == Que->capacity ? true :false;}void* Queue_Front(const XHQUEUE_T Que)//只查询{    if(Queue_IsEmpty(Que)) return NULL;    return Que->data[Que->front];}bool Queue_DeQueue(XHQUEUE_T Que, OPERATE op, void** data){    if(Queue_IsEmpty(Que)) return false;    if(op != NULL && data != NULL)    {        *data = Que->data[Que->front];        Que->callback = op;        Que->callback(*data);    }    Que->front = (Que->front++)%Que->capacity;    Que->len_queue--;    return true;}bool Queue_EnQueue(XHQUEUE_T Que,void* data){    if(Queue_IsFull(Que)) return false;    Que->rear =(Que->rear++)%Que->capacity;    Que->data[Que->rear] = data;    Que->len_queue++;    return true;}bool Queue_DeleteAll(XHQUEUE_T Que,OPERATE op, void** data){    while(!Queue_IsEmpty(Que))    {        Queue_DeQueue(Que,op,data);    }    free(Que->data);    Que->data = NULL;    free(Que);    Que= NULL;    return true;}int Queue_GetCapacity(XHQUEUE_T Que){    if(Que == NULL) exit(0);    return Que->capacity;}int Queue_GetLen(XHQUEUE_T Que){    if(Que == NULL) exit(0);    return Que->len_queue;}

以上是数组式的队列，我们还可以实现为链式循环队列
队列结构

struct node{    void *data;    struct node* next;};struct XHqueue{    int capacity;    int len;    struct node* front;    struct node* tail;};

注意实现是带有头结点和尾结点（即这两个结点实际上是不存储data的，方便队列操作和实现的，所以容量实际比最大有效长度多2 ），因此，在访问队首元素是也是要用front->next来访问。
接口：

typedef (*OPERATE)();typedef enum{    false = 0,    true,}bool;struct node;typedef struct node NODE;typedef struct node* NODE_T;struct Queue;typedef struct XHqueue XHQUEUE;typedef struct XHqueue* XHQUEUE_T;XHQUEUE_T Queue_Init(XHQUEUE_T Que,int N);bool Queue_IsEmpty(const XHQUEUE_T Que);bool Queue_IsFull(const XHQUEUE_T);void* Queue_Front(const XHQUEUE_T Que);bool Queue_DeQueue(XHQUEUE_T Que, OPERATE op, void** data);bool Queue_EnQueue(XHQUEUE_T Que,void* data);bool Queue_DeleteAll(XHQUEUE_T Que,OPERATE op, void** data);int Queue_GetCapacity(XHQUEUE_T Que);int Queue_GetLen(XHQUEUE_T Que);NODE_T Que_NodePOrevious(XHQUEUE_T Que,NODE_T nd);#endif

功能从函数名称可以看出，还有具体的细节和前面几篇文章其实是相同的，所以直接上实现

#include"tongyongxunhuanlianshi.h"struct node{    void *data;    struct node* next;};/**发现还是要带头尾部节点比较好*/struct XHqueue{    int capacity;    int len;    struct node* front;    struct node* tail;};XHQUEUE_T Queue_Init(XHQUEUE_T Que,int N){    if(N<0) return NULL;    Que = (XHQUEUE_T)malloc(sizeof(struct XHqueue));    if(Que==NULL) return NULL;    Que->capacity = N;    Que->len = 0;    Que->front = (NODE_T)malloc(sizeof(NODE));    Que->tail = (NODE_T)malloc(sizeof(NODE));    if(Que->front == NULL ||Que->tail == NULL)    {        free(Que);        Que = NULL;        return NULL;    }    Que->front->next = Que->tail;    Que->tail->next = Que->front;    Que->front->data = NULL;    Que->tail->data = NULL;    Que->len = 0 ;    return Que;}bool Queue_IsEmpty(const XHQUEUE_T Que){    if(Que == NULL) return false;   return Que->front->next== Que->tail&&Que->tail->next== Que->front ? true : false;}bool Queue_IsFull(const XHQUEUE_T Que){    if(!Queue_IsEmpty(Que))    {        return Que->len >= Que->capacity ? true : false;    }    return false;}void* Queue_Front(const XHQUEUE_T Que){    if(Queue_IsEmpty(Que)) NULL;    return Que->front->next->data;}bool Queue_DeQueue(XHQUEUE_T Que, OPERATE op, void** data){    NODE_T tmp = NULL;    if(Queue_IsEmpty(Que)) return false;    tmp = Que->front->next;    Que->front->next = tmp->next;    if(op!=NULL&&data!=NULL)    {        *data = tmp->data;        op(*data);    }    free(tmp);    tmp = NULL;    Que->len--;    return true;}bool Queue_EnQueue(XHQUEUE_T Que,void* data){    NODE_T newnode = (NODE_T)malloc(sizeof(NODE));    NODE_T pre = NULL;    if(newnode==NULL) return false;    newnode->data = data;    newnode->next = NULL;    if(Queue_IsFull(Que))    {            free(newnode);            newnode = NULL;            return false;    }    else    {            pre = Que_NodePOrevious(Que,Que->tail);            newnode->next = Que->tail;            pre->next = newnode;            Que->len++;                return true;    }}NODE_T Que_NodePOrevious(XHQUEUE_T Que,NODE_T nd){    NODE_T Head;    if(Que==NULL) return NULL;    Head = Que->front;    while(Head->next != Que->front)    {        if(Head->next == nd) return Head;        Head = Head->next;    }    if(Head->next != Que->front) return NULL;}bool Queue_DeleteAll(XHQUEUE_T Que,OPERATE op, void** data){    if(Que == NULL) return false;    while(!Queue_IsEmpty(Que))    {        Queue_DeQueue(Que,op,data);        if(Queue_IsEmpty(Que)) break;    }    if(op!=NULL&&data!=NULL)    {        *data = Que->tail->data;        op(*data);        *data = Que->front->data;        op(*data);    }        free(Que->tail);        free(Que->front);        free(Que);        Que=NULL;        return true;}int Queue_GetCapacity(XHQUEUE_T Que){    if(Que == NULL) exit(0);    return Que->capacity;}int Queue_GetLen(XHQUEUE_T Que){    if(Que == NULL) exit(0);    return Que->len;}

至此就完成两种方式的实现了！（线性数据结构终于看完了^_^）