DataStructure-4-队列

4.1 队列

4.1.1 循环队列

     队列的顺序存储结构称为循环队列.

    

        

    队列为null的条件是rear=front。

4.1.2   循环队列的实现

 CriQueue.h

ifndef CIRQUEUE_H
#define CIRQUEUE_H

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

typedef int DataType;

typedef struct CirQueue
{
    DataType *data;
    int front;
    int rear;
}CirQueue;

int InitCirQueue(CirQueue *C);
int EnQueue(CirQueue *C,DataType e);
DataType DeQueue(CirQueue *C);
DataType GetQueue(CirQueue *C);

#endif

 CriQueue.c

#include "CirQueue.h"

const int QueueSize = 10;

int InitCirQueue(CirQueue *C)
{
    C->data = (DataType *)malloc(QueueSize*sizeof(DataType));
    if(C->data == NULL)
        return 0;
    //初始化空队列
    C->front = C->rear = QueueSize - 1;
    return 1;
}

int EnQueue(CirQueue *C,DataType e)
{
    if((C->rear+1)%QueueSize == C->front) //队满
    {
        printf("Queue if full!\n");
        return 0;

    }
    C->rear = (C->rear + 1)%QueueSize;
    C->data[C->rear] = e;

    return 1;
}

DataType DeQueue(CirQueue *C)
{
    if((C->rear) == (C->front)) //队空
    {
        printf("Queue if null\n");
        return 0;
    }
    C->front = (C->front + 1)%QueueSize;
    return C->data[C->front];
}

DataType GetQueue(CirQueue *C)
{
    int i;
    if((C->rear) == (C->front))
    {
        printf("Queue if null\n");
        return 0;
    }
    i = (C->front + 1)%QueueSize;
    return C->data[i];
}

   
main.c

#include "CirQueue.h"

int main(void)
{
    CirQueue C;
    //初始化队列
    InitCirQueue(&C);
    //入队列
    EnQueue(&C,1);
    EnQueue(&C,2);
    EnQueue(&C,3);
    //出队列
    printf("DeQueue:%d\n",DeQueue(&C));
    //获取队头元素
    printf("Get Queue:%d\n",GetQueue(&C));


    return 0;
}

4.2链队列

    4.2.1链队列

    队列的链接存储结构称为链队列

 

    

 

  4.2.2链队列的实现

  LinkQueue.h

#ifndef LINKQUEUE_H
#define LINKQUEUE_H

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

typedef int DataType;

typedef struct Node
{
    DataType data;
    struct Node *next;
}Node,*QueueStr;

typedef struct
{
    QueueStr front;
    QueueStr rear;
}LinkQueue;

int InitLinkQueue(LinkQueue *L);
int EnQueue(LinkQueue *L,DataType e);
DataType DeQueue(LinkQueue *L);
DataType GetQueue(LinkQueue *L);
int DestoryQueue(LinkQueue *L);

#endif

  LinkQueue.c

#include "LinkQueue.h"

int InitLinkQueue(LinkQueue *L)
{
    L->front = L->rear =(QueueStr)malloc(sizeof(Node));
    if(L->front == NULL)
    {
        printf("Init Queue Error\n");
        return 0;
    }
    L->front->next=NULL;

    return 1;
}

int EnQueue(LinkQueue *L,DataType e)
{
    Node *p;
    p = (Node *)malloc(sizeof(Node));
    p->data = e;
    p->next = NULL;
    L->rear->next = p; //尾插法
    L->rear = p;  //尾指针后移

    return 1;
}

DataType DeQueue(LinkQueue *L)
{
    DataType e;
    Node *p = NULL;
    //判断队列是否为空
    if(L->front == L->rear)
    {
        printf("Queue is NULL\n");
        return 0;
    }
    p=L->front->next;
    e=p->data;
    L->front->next = p->next;
    //删除之后判断队列是否为空
    if(p->next == NULL)
    {
        L->rear = L->front;
    }
    free(p);//释放
    return e;
}

DataType GetQueue(LinkQueue *L)
{
    if(L->front == L->rear)
    {
        printf("Queue is NULL\n");
        return 0;
    }
    return L->front->next->data;
}

int DestoryQueue(LinkQueue *L)
{
    Node *p = NULL;
    while(L->front)
    {
        p = L->front->next;
        free(p);
        L->front = p;
    }
    return 1;
}

 main.c

#include "LinkQueue.h"

int main(void)
{
    LinkQueue L;

    //初始化
    InitLinkQueue(&L);

    //入队列
    EnQueue(&L,1);
    EnQueue(&L,2);
    EnQueue(&L,3);
    //出队列
    printf("DeQueue:%d\n",DeQueue(&L));
    //获取队头元素
    printf("Get Queue:%d\n",GetQueue(&L));
    //销毁队列
    DestoryQueue(&L);
    printf("Destory after Get Queue:%d\n",GetQueue(&L));
     return 0;
}

4.3循环队列与链队列的比较: