队列的基本操作

队列的顺序存储

//队列的顺序存储

//附设两个指针，队头指针front指向队头元素，
//队尾指针指向队尾元素的下一个位置。
#include<stdio.h>
#define MaxSize 20//定义队列中元素的最大个数

//附设两个指针，队头指针front指向队头元素，
//队尾指针指向队尾元素的下一个位置。
typedef struct{
    int data[MaxSize];//存放队列元素
    int front,rear;//队头指针和队尾指针
}SqQueue;

void InitQueue(SqQueue &Q){
    //初始化时，队头，队尾指针指向0
    Q.rear=Q.front=0;
}

bool isEmpty(SqQueue Q){
    return (Q.rear==Q.front);
}


//获得队头元素的值，用x返回
bool GetHead(SqQueue Q, int &x){
    if(Q.front == Q.rear){
        printf("Queue is empty\n");
        return false;
    }
    x = Q.data[Q.front];
    return true;
}

循环队列

#include<stdio.h>
#define MaxSize 20//定义队列中元素的最大个数

typedef struct{
    char data[MaxSize];//存放队列元素
    int front,rear;//队头指针和队尾指针
}SqQueue;

void InitQueue(SqQueue &Q){
    //初始化时，队头，队尾指针指向0
    Q.rear=0;
    Q.front=0;
}

bool isEmpty(SqQueue Q){
    return (Q.rear==Q.front);
}


//获得队头元素的值，用x返回
bool GetHead(SqQueue Q, int &x){
    if(Q.front == Q.rear){
        printf("Queue is empty\n");
        return false;
    }
    x = Q.data[Q.front];
    return true;
}

bool EnQueue(SqQueue &Q,int x){
    if(Q.front == (Q.rear+1)%MaxSize){//@@@
        printf("???");
        printf("队列已满\n");
        return false;
    }
    Q.data[Q.rear]=x;
    Q.rear=(Q.rear+1)%MaxSize;//队尾指针+1
}

bool DeQueue(SqQueue &Q, int &x){
    if(Q.rear == Q.front){
        printf("队列为空\n");
        return false;
    }
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
    return true;
}

bool PrintQueue(SqQueue Q){
    int p=Q.front;
    if(p==Q.rear){
        printf("队列空\n");
        return false;
    }
    printf("Queue is:");
    while(p!=Q.rear){
        printf("%d ",Q.data[p++]);
    }
    printf("\n");
    return true;
}

int main(){
    SqQueue Q;
    InitQueue(Q);
    for(int i=1;i<5;i++){
        EnQueue(Q,i);
    }
    PrintQueue(Q);

    EnQueue(Q,100);
    PrintQueue(Q);
    int e;
    DeQueue(Q,e);
    printf("after DeQueue:%d \n",e);
    PrintQueue(Q);
}

队列的链式存储

                         不带头结点

因为队列的每个结点只需要保存结点本身的值和指向下一个结点的指针，而链队列又需要有头指针和尾指针，所以要两个类型的结构体：描述结点类型的结构体 和 描述头尾指针的结构体

1. 入队列时，需要先判断原队列是否为空
2. 出队列时，需要判断原队列是否为空； 还要考虑本身只有一个结点的出队情况
3. 此为不带头结点的链队列

//队列的链式存储，链队列   不带头结点
//实际上是一个同时带有队头指针和队尾指针的单链表
//头指针指向头结点，尾指针指向尾结点
#include<stdlib.h>
#include<stdio.h>

typedef struct LinkNode{//链式队列结点
    int data;
    struct LinkNode *next;
}LinkNode;
typedef struct{//链式队列
    LinkNode *front,*rear;//队列的队头和队尾指针
}LinkQueue;

void InitQueue(LinkQueue &Q){
    Q.front=Q.rear=NULL;
}

bool IsEmpty(LinkQueue Q){
    return (Q.front==NULL);
    //或者return (Q.rear==NULL);
}

bool EnQueue(LinkQueue &Q, int x){
    LinkNode *s=(LinkNode*)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    if(Q.front==NULL){//原来为空队列

        Q.front = s;
        Q.rear=s;
    }
    else{
        Q.rear->next = s;//新结点插到尾部
        Q.rear=s;//@@@修改尾指针！！！
        //printf("？？？%d \n",Q.rear->data);
    }
    return true;
}

bool DeQueue(LinkQueue &Q, int &x){
    if(Q.front == NULL){//@@@
        printf("空队列\n");
        return false;
    }
    LinkNode *p=Q.front;//p指向此次出队的结点
    x=Q.front->data;
    Q.front=p->next;
    if(Q.rear==p){//此次出队的是最后一个结点
        Q.front=Q.rear=NULL;
    }
    free(p);//@@@
    p=NULL;
    return true;
}

bool PrintQueue(LinkQueue Q){
    if(!Q.front){
        printf("空队列无法打印\n");
        return false;
    }
    LinkNode *p=Q.front;
    printf("Queue is:");
    while(p){
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
    return true;
}

int main(){
    LinkQueue Q;
    InitQueue(Q);
    for(int i=1;i<5;i++){
       // printf("i=%d \n",i);
        EnQueue(Q,i);
    }
    PrintQueue(Q);

    int x;
    DeQueue(Q,x);
    printf("after delete %d\n",x);
    PrintQueue(Q);


}