数据结构之线性结构应用之一----队列

队列（queue）

一、定义

　　一种可以实现“先进先出”（FIFO）的存储结构，即先进入队列的数据先取出来。

二、分类

• 链式队列：链表实现，实现难度比静态队列低很多
• 静态队列：数组实现，静态队列通常都必须是循环队列

三、程序实现前该解决的问题

（1）静态队列为什么必须是循环队列？

　　因为front、rear两个都只能只增不减，为了充分利用数组静态的内存，故采用循环队列。使用求余号%解决。

（2）循环队列需要几个参数来确定？

　　需要两个参数：front、rear，两个参数不同场合有不同的含义

四、静态队列基本操作

• 入队伪算法：

　　　　1.将值存入rear所代表的位置；

　　　　2.正确的写法：r=(r+1)%数组长度，实现循环移动

• 出队伪算法：

　　　　1.将front所代表的位置取出

　　　　2.f=(f+1)%数组长度

• 判空/满

　　程序实现：

#include<stdio.h>
#include<malloc.h>

typedef struct Queue
{
    int *pBase;
    int front;
    int rear;
}QUEUE,*PQUEUE;

void init_queue(PQUEUE);
int en_queue(PQUEUE,int);
int out_queue(PQUEUE,int *);
void traverse_queue(PQUEUE);
int is_full_queue(PQUEUE);
int is_empty_queue(PQUEUE);


int main()
{
    QUEUE Q;
    int val;

    init_queue(&Q);
    en_queue(&Q,1);
    en_queue(&Q,2);
    en_queue(&Q,3);
    en_queue(&Q,4);
    en_queue(&Q,5);
    en_queue(&Q,6);
    traverse_queue(&Q);
    out_queue(&Q,&val);
    printf("出栈：%d\n",val);
    traverse_queue(&Q);
    return 0;
}

void init_queue(PQUEUE pQ)
{
    pQ->pBase=(int *)malloc(sizeof(int)*6);
    pQ->front=0;
    pQ->rear=0;
}

int en_queue(PQUEUE pQ,int val)
{
    if(is_full_queue(pQ))
        return 0;
    *(pQ->pBase+pQ->rear)=val;
    pQ->rear=(pQ->rear+1)%6;
    return 1;
}

int is_full_queue(PQUEUE pQ)
{
    if((pQ->rear+1)%6==pQ->front)
        return 1;
    return 0;
}

void traverse_queue(PQUEUE pQ)
{
    int i=pQ->front;
    while(i!=pQ->rear)
    {
        printf("%d ",*(pQ->pBase+i));
        i=(i+1)%6;
    }
    printf("\n");
    return;
}

int is_empty_queue(PQUEUE pQ)
{
    if(pQ->rear == pQ->front)
        return 1;
    return 0;
}

int out_queue(PQUEUE pQ,int *val)
{
    if(is_empty_queue(pQ))
    {
        printf("空\n");
        return 0;
    }
    else
    {
        *val=*(pQ->pBase+pQ->front);
        pQ->front=(pQ->front+1)%6;
    }
    return 1;
}

五、链式队列的基本操作

　　队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已。为了操作上的方便，我们将对头指针指向该队列的头结点，而队指针指向终端节点。

typedef struct Node
{
    int data;
    struct Node *pNext;
}NODE,*PNODE;

typedef struct
{
    PNODE rear,front;
}LinkQueue;

int EnQueue(LinkQueue *Q,int e)
{
    PNODE s=(PNODE)malloc(sizeof(NODE));
    if(!s)
        exit(-1);
    s->data=e;
    s->pNext=NULL;
    Q->rear->pNext=s;
    Q-->rear=s;
    return 1;
}

int DeQueue(LinkQueue *Q,int *e)
{
    PNODE p;
    if(Q->front==Q->rear)
        return -1;
    p=Q->front->pNext;
    *e=p->data;
    Q->front->next=p->next;
    if(Q->rear==p)
        Q->rear=Q->front;
    free(p);
    return 1;
}