数据结构与算法——循环队列链式队列

队列
1、也是一种操作受限的线性表，规定只能在一端插入，一端删除，有先进先出的特点。
2、顺序队列，队首指针指向队首元素，队尾指针指向队尾元素的前一个元素，此时队列为空的判定条件是

Q.front == Q.rear == 0;

2、顺序队列会有假溢出的现象，为此设计了循环队列。
1）为了区分队满和队空的条件，循环队列往往采用少用一个单元进行入队

队满判定条件：（Q.rear+1）%maxSize == Q.front;
队空条件：Q.front == Q.rear
队中元素的个数：(Q.rear+maxSize-Q.front)%MaxSize

2）也可以在类型中增设size属性

队空：Q.size == 0 && Q.front == Q.rear
队满：Q.size == maxSize-1 && Q.front == Q.rear

顺序循环队列实现代码
一般循环队列默认是顺序队列，因为链式队列不会考虑存储空间和溢出的问题，
此串代码入队enQuene（）有问题，不能实现入队操作，待解决

/*
循环队列，队首指针指向队首元素，队尾指针指向队尾元素的前一个元素
*/
#include
#include
#define MAXSIZE 10

typedef int ELEMTYPE;
typedef enum{
    SUCCESS,ERROR,EMPTY,FULL
}STATUS;

typedef struct{
    ELEMTYPE data[MAXSIZE];
    int front,rear;
}SqQuene;

/*
初始化队首队尾指针 
*/
STATUS init(SqQuene &q){
    q.front = 0;
    q.rear = 0;
}
/*
判断队列是否为空 
*/
bool emptyQuene(SqQuene q){
    if(q.front == q.rear == 0){
        return true;
    }
    return false;   
} 
/*
判断队列是否为满 
*/
bool fullQuene(SqQuene q){
    if((q.rear+1)%MAXSIZE == q.front){
        return true;
    }
    return false;
} 
/*
FIXME 
入队 
*/

STATUS enQuene(SqQuene &q,ELEMTYPE x){
    if(fullQuene(q)){
        return FULL;
    }
    q.data[q.rear] = x;
    q.rear = (q.rear+1)%MAXSIZE;
    return SUCCESS;
} 
/*
出队 
*/
STATUS deQuene(SqQuene &q,ELEMTYPE &x){
    if(emptyQuene(q)){
        return EMPTY;
    }
    q.data[q.front] = x;
    q.front = (q.front+1)%MAXSIZE;
    return SUCCESS;
}
/*
打印 
*/
void printQuene(SqQuene q){
    if(emptyQuene(q)){
        printf("队列为空\n");
    }
    int index = 0; 
    index = q.front%MAXSIZE;
    while(index <= q.rear){
        printf("data:%-5d",q.data[index]);
        index += 1%MAXSIZE; 
    }
    printf("\n");
} 

int main(void){

    SqQuene q;
    int x = 0;
    int len = 10;
    printf("判空：%d\n",emptyQuene(q));
    printf("判满：%d\n",fullQuene(q));
    for(int  i= 0;i100+1);        
    }
    printQuene(q);

    printf("出队\n");
    for(int i = 0;iprintf("%-5d",x);
    }
    printf("\n");


    return 0;
} 

---

---

链式队列实现代码

/*
带头结点的链式队列，
队首指针（头结点）指向队首结点，
队尾指针指向队尾结点 
*/
#include
#include
#define MAXSIZE 10

typedef int ELEMTYPE;

typedef enum{
    ERROR,SUCCESS,EMPTY,FULL
}STATUS;

typedef struct LinkNode{
    ELEMTYPE data;
    struct LinkNode *next;
}LinkNode;
typedef struct{
    LinkNode *front,*rear;  
}LinkQuene;
/*
初始化 
*/
STATUS init(LinkQuene &Q) {
    Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
    if(!(Q.front && Q.rear)){
        return ERROR;
    }
    Q.front->next = NULL;   
    return SUCCESS;
}
/*
判空 
*/
bool emptyQuene(LinkQuene Q){
    if(Q.front == Q.rear){
        return true;
    }
    return false;
}
/*
入队 
*/
STATUS enQuene(LinkQuene &Q,ELEMTYPE x){
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    if(!s){
        return ERROR;
    }
    s->data = x;
    s->next = NULL;
    Q.rear->next = s;
    Q.rear = s;
    return SUCCESS;
} 
/*
出队 
*/ 
STATUS deQuene(LinkQuene &Q,ELEMTYPE &x){

    if(Q.front == Q.rear){
        return EMPTY;
    }
    LinkNode *s = Q.front->next;
    x = s->data;
    Q.front->next = s->next;
    if(Q.rear == s){
        Q.rear = Q.front;
    }
    free(s);
    return SUCCESS;
}
STATUS printQuene(LinkQuene Q){
    if(emptyQuene(Q)){
        printf("队空\n");
        return EMPTY; 
    }
    LinkNode * s= Q.front;
    while(s->next){
        s = s->next;
        printf("%-5d",s->data);     
    }
    printf("\n");
    return SUCCESS;

}
int main(void){
    LinkQuene Q;
    ELEMTYPE x = 0;
    STATUS status = init(Q);
    //printf("%d\n",status);
    int a[] = {1,2,3,4,5,6,7,8,9};
    for(int i = 0;i<sizeof(a)/sizeof(int);i++){
        enQuene(Q,a[i]);
    }
    printf("入队后遍历队列\n"); 
    printQuene(Q);
    printf("出队序列\n");
    while(deQuene(Q,x) != 2){
        printf("%-5d",x);
    }   
    printf("\n");


    return 0;
}