队列的比较和存储方式

笔记和代码的思路来源：

好大学慕课浙江大学陈越、何钦铭的《数据结构》

队列：
    1.介绍
    一种数据结构，遵循先进先出的原则，插入只能在一端进行，删除必须在另一端
    数据插入：入队列
    数据删除：出队列
    
    2.数据抽象
    队列的抽象数据类型：
        类型名称：队列(Queue)
        数据对象集：一个有0个或者多个元素的又穷线性表

        操作集：长度为maxSize的队列 Q 属于 Queue 队列元素item 属于 elementType

        1.Queue createQueue(int maxSize)        生成长度为maxSize的空队列
        2.int isFullQueue(Queue q ,int maxSize)        判断队列是否满了
        3.void addQueue(Queue q,elementType item)    将数据元素item插入到队列中
        4.int isEmptyQueue(Queue q)            判断队列是否为空
        5.elementType delete(Queue q)            将对头元素进行删除
    
    3.队列的表现形式
        3.1使用数组来表示
            一般可以选择将队列的头放在数组下标小的位置，将队尾放在数组角标比较大的位置，并使用两个变量font和rear分别
            表示队列的头和尾。一般初始化font和rear为-1，当有元素入队列时，rear+1，出队列时font+1,在删除对头元素
            但是使用上面的存储会存在一个问题，
             ...| | | | | | | | |
                   f       r    
            如果此时r=maxSize-1,就无法在向队列里面添加元素了，但是队列实际上在f之前，还是可以插入元素的
            这个现象称为假溢出
        
            为了解决这样的问题，我们使用循环队列的方式。详细的可以参考书上的图片或者视频
            使用循环队列还是有一个问题，当队列为空时rear==font,当队列满时，read==font
            那么这样就产生了歧义，如何区分队列是空还是满呢。

            方法一：使用一个flag变量记录最后一次操作是入队列还是出队列，如果是入队列导致rear==font,那么队列是满的
                如果是出队列导致rear==font，那么队列是空大。
            方法二：少用一个元素空间，当(rear+1)%maxSize == font 时，我们认为队列就满了。
            队列空的判断条件仍然为 rear==font
            我们的代码演示是基于方法二的。


        3.2 队列的链式存储
            队列的链式存储我们只要确定用哪个指针指向头结点，哪个指针指向尾节点即可
            对于头节点，添加删除均可
            对于尾节点，只能做添加操作，不方便做删除操作

            所有我们这里用font指针指向头节点，用rear指针指向尾结点
            

    

    代码：

循环队列的数组存储：

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100

//定义一个循环队列的数组存储。
typedef struct node{
    int data[MAXSIZE];
    int rear;
    int font;
}que,*pQueue;


pQueue createEmptyQueue(){
    pQueue queue;
    queue =(pQueue)malloc(sizeof(que));
    if(queue){
        queue->font=-1;
        queue->rear=-1;
    }
    return queue;
}

int isQueueFull(pQueue queue){
    return ((queue->rear+1)%MAXSIZE) == (queue->font);
}

int isQueuempty(pQueue queue){
    return queue->font == queue->rear;
}

void addQueue(pQueue queue,int element){
    if(isQueueFull(queue)){
        printf("the queue has been filled,don't allow to put other elememt
");
    }else{
        queue->rear = (queue->rear+1)%MAXSIZE;
        queue->data[queue->rear]=element;
    }
}

int deleteQueue(pQueue queue){
    if(isQueuempty(queue)){
        printf("the queue is null,don't allow delete element from it");
        return;
    }else{
        queue->font = (queue->font+1)%MAXSIZE;
        return queue->data[queue->font];
    }
}


void toString(pQueue queue){
    int i=queue->font+1;
    while(i<=queue->rear){
        printf("%d ",queue->data[i%MAXSIZE]);
        i++;
    }
}


void main(){
    pQueue queue = createEmptyQueue();
    addQueue(queue,1);
    addQueue(queue,2);
    addQueue(queue,3);
    addQueue(queue,4);
    addQueue(queue,5);
    deleteQueue(queue);
    toString(queue);
}

队列的链式存储

#include<stdio.h>
#include<stdlib.h>



//定义一个存在队列元素的链表
typedef struct node1{
    int element;
    struct node1 *next;
}lis,*pList;

//定义队列的链式存储，使用font指向头部，rear指向尾部
typedef struct node2{
    struct node1 *font;
    struct node1 *rear;
}que,*pQueue;


pList createEmptyList(){

    pList list;
    list = (pList)malloc(sizeof(lis));
    if(list){
        list->next=NULL;
    }
    return list;
}
pQueue createEmptyQueue(){

    pQueue queue;
    queue = (pQueue)malloc(sizeof(que));
    if(queue){
        queue->font=NULL;
        queue->rear=NULL;
    }
    return queue;
}

int isQueueEmpty(pQueue queue){
    return (queue->font==NULL);
}

void addQueue(pQueue queue,int element){
    if(isQueueEmpty(queue)){
        pList list = createEmptyList();
        list->element = element;
        queue->font=list;
        queue->rear=list;
    }else{
        pList list = (pList)malloc(sizeof(lis));
        list->element=element;
        list->next = queue->rear->next;
        queue->rear->next = list;
        queue->rear=list;
    }

}

int deleteQueue(pQueue queue){
    if(isQueueEmpty(queue)){
        printf("the queue is empty,don't allow delete element from it");
        return;
    }
    pList node = queue->font;
    int element = node->element;
    if(queue->font==queue->rear){
        queue->font = queue->rear = NULL;
    }else{
        queue->font = queue->font->next;
    }
    free(node);
    return element;
}

void toString(pQueue queue){
    pList p = queue->font;
    while(p!=NULL){
        printf("%d ",p->element);
        p = p->next;
    }
}

void main(){
    pQueue queue = createEmptyQueue();
    addQueue(queue,1);
    addQueue(queue,2);
    addQueue(queue,3);
    addQueue(queue,4);
    addQueue(queue,5);
    addQueue(queue,6);
    deleteQueue(queue);
    toString(queue);
}