队列

最新推荐文章于 2024-09-15 11:40:06 发布

weixin_30737433

最新推荐文章于 2024-09-15 11:40:06 发布

阅读量105

点赞数

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/tianzeng/p/9695902.html

版权

概念

　　队列是一种特殊的线性表，只允许在表的头部（front处）进行删除操作，在表的尾部（rear处）进行插入操作的线性数据结构，这种结构就叫做队列。进行插入操作的一端称为队尾，进行删除操作的一端称为队尾；是一种采用先进先出(FIFO)策略的抽象数据结构

链队列

　　使用单向链表来实现链式队列，链式队列中存储front和rear即可

1.结构

typedef struct Node
{
    int data;
    struct Node* next;
}LinkQueueNode;

typedef struct
{
    LinkQueueNode* f;
    LinkQueueNode* l;
}LinkQueue;

2.判断队列是否为空

　　在链式队列中，不需要考虑队列是否已满，只要内存足够就可以一直分配空间。而当front和rear都指向头节点的时候，则表示此时队列为空。

bool IsEmpty(LinkQueue *q)
{
    return q->f==q->l;
}

入队及出队的完整代码

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

#define len sizeof(LinkQueueNode)

typedef struct Node
{
    int data;
    struct Node* next;
}LinkQueueNode;

typedef struct
{
    LinkQueueNode* f;
    LinkQueueNode* l;
}LinkQueue;

//初始化头结点为空,从第二个节点输入数据 
void InitNode(LinkQueue *q)  
{
    q->f=(LinkQueueNode *)malloc(len);
    if(q->f!=NULL)
    {
        q->l=q->f;
        q->f->next=NULL;
    }
}

void EnterQueue(LinkQueue *q,int a[],int x)//入队 
{
    LinkQueueNode *NewNode;
    for(int i=0;i<x;i++)
    {
        NewNode=(LinkQueueNode *)malloc(len);
        if(NewNode!=NULL)
        {
            NewNode->data=a[i];
            NewNode->next=NULL;
            q->l->next=NewNode;
            q->l=NewNode;
        }
    }
}

void DeleteQueue(LinkQueue *q,int *x) 
{
    LinkQueueNode *p;
    if(q->f==q->l)
    {
        printf("队列为空.\n");
        exit(1);
    }
    p=q->f->next;
    q->f->next=p->next;
    if(q->f==q->l)//如果队列中只有一个元素，出队后为空队 
        q->l=q->f;
    
    *x=p->data;
    free(p);
}
//打印队列中的元素 
void PrintQueue(LinkQueue *q)
{
    LinkQueueNode *s;
    s=q->f->next;                        //从第二个节点输入数据 
    for(;s!=NULL;s=s->next)
    {
        printf("%-3d",s->data);
    }
    printf("\n");
}

int main()
{
    int x;
    LinkQueueNode *NewNode;
    LinkQueue q;
    InitNode(&q);
    
    printf("请输入队列的长度:\n");
    scanf("%d",&x);
    int a[x];
    printf("请输入队列中的元素:\n");
    for(int i=0;i<x;i++)
        scanf("%d",&a[i]);
    EnterQueue(&q,a,x);
    printf("列中的元素为:\n");
    PrintQueue(&q);

    int t;
    printf("出队后队列中的元素为:\n");
    DeleteQueue(&q,&t);
    PrintQueue(&q);
    printf("出队的元素为:%d\n",t);
    free(NewNode);
    return 0;
}

循环队列

　　循环队列仍然是基于数组实现的。但是为了形象化的说明问题，我们如下图所示

　　　　1.图中有两个指针(其实就是两个整数型变量，因为在这里有指示作用，所以这里理解为指针)front、rear,一个指示队头，一个指示队尾。

　　　　2.rear和front互相追赶着，这个追赶过程就是队列添加和删除的过程，如果rear追到head说明队列满了，如果front追到rear说明队列为空。

　　　　　　说明：令队列空间中的一个单元闲置，使得队列非空时，Q.rear与Q.front之间至少间隔一个空闲单。

　　　　3.我们把它掰弯，用的是求余，这样两个值就不会跑出最大范围，并且可以实现弯曲的效果，所以说对于循环队列我们必须给定最大值MAXQSIZE。

　　　　这其实是我们臆想的，反正我们要做的就是利用循环来解决空间浪费的问题。　　

　　　 4.在非空循环队列中，队头指针始终指向当前的队头元素，而队尾指针始终指向真正的队尾元素的后面单元

循环队列的实现过程

　　方法一：损失一个元素方法

　　　　当队尾指针指向的空单元的后继单元是队头元素所在的单元时，停止入队。这样队尾指针永远追不上队头指针，也不会有front==rear

　　　　☆当添加一个元素时,(rear+1)%MAXQSIZE; //便于解决由最大下标位置移到到0下标时的越界处理

　　　　☆当删除一个元素时,(front+1)%MAXQSIZE；

　　　　☆当rear=front的时候，队列可能是满，也可能是空。

　　　　　　因为存在满和空两种情况，我们需要分别判断：

　　　　　　　　☆满：当队列添加元素到rear的下一个元素是head的时候，也就是转圈子要碰头了，我们就认为队列满了。(Q.rear+1)%MAXSIZE=Q.front

　　　　　　　　☆空：当队列删除元素到head=rear的时候，我们认为队列空了。Q.rear==Q.front,不一定为0　　

　　有关模取问题：

　　　　便于解决由最大下标位置移到到0下标时的越界处理。例：假设有MAXQSIZE=60(0~59)的一个数组，存储一个满循环队列Q 队列为空时，初始化Q.front=Q.rear=0 队列为满时：Q.front=0,Q.rear=59 ps：这里我们可以探讨为什么要对MAXQSIZE取余求模，详如下：如果不取余：Q.rear+1=59+1=60,数组中最大下标为59而无60显然不取余是不对的取余后：（Q.rear+1）%MAXQSIZE=（59+1）%60=60%60=0，而Q.front=0,因此可以构成判断。

#include<stdio.h>
#define max 3

typedef struct 
{
    int data[max];
    int front;
    int rear;
}SeqQueue;

void InitSeqQueue(SeqQueue *Q)
{
    Q->front=Q->rear=0;
}

void EnterQueue(SeqQueue *Q,int a[],int x)
{
    if((Q->rear+1)%max==Q->front)
    {
        printf("队满!\n");
        return;
    }
    else
    {
        for(int i=0;i<x;i++)
        {
            Q->data[Q->rear]=a[i];
            Q->rear=(Q->rear+1)%max;
        }
    }
}

void DeleteQueue(SeqQueue *Q)
{
    if(Q->rear==Q->front)
    {
        printf("队列为空!\n");
        return ;
    }
    else
    {
        Q->front=(Q->front+1)%max;
    }
}

void PrintQueue(SeqQueue *Q)
{
    for(int i=Q->front;i<Q->rear;i++)
    {
        printf("%-3d",Q->data[i]);
    }
    printf("\n");
}

int LengthSeqQueue(SeqQueue Q)
{
    return (Q.rear-Q.front+max)%max;
/*为什么要加上一个max因为会有一种情形 比如 队列是0~5，maxsize应该是6,队首指向3，队尾指向1，此时队列长度应该是4,
但是用Qrear- Qfront = -2，显然不是队列的长度,所以要加上 6，在对max求余，才可以算出来.*/

}

int main()
{
    SeqQueue Q;
    int x,length;
    InitSeqQueue(&Q);
    printf("请输入要入队的元素的个数：\n");
    scanf("%d",&x);
    int a[x];
    printf("请输入要入队的元素:\n") ;
    for(int i=0;i<x;i++)
        scanf("%d",&a[i]);
    EnterQueue(&Q,a,x);
    DeleteQueue(&Q);
    printf("队列中的元素为:\n");
    PrintQueue(&Q);
    printf("队列的长度为：\n");
    length=LengthSeqQueue(Q);
    printf("%-3d\n",length);
    return 0;
}

　　也可用这种方法遍历

void traverse_queue(QUEUE *pQ)
{
    int i=pQ->front;  //令i从“头”开始遍历
    printf("%d ",pQ->pBase[i]);
    
    while(i!=pQ->rear)
        i=(i+1)%6;  //将i向下移动一个位置 
      
}

　　方法二：设置一个标志量，初始化产生一个空循环队列

typedef struct 
{
    int data[max];
    int front;
    int rear;
    int flag;//标志量 
}SeqQueue;

完整代码

#include<stdio.h>

#define max 3

typedef struct 
{
    int data[max];
    int front;
    int rear;
    int flag;//标志量 
}SeqQueue;

void InitQueue(SeqQueue *Q)
{
    Q->front=Q->rear=0;
    Q->flag=0;
}

void EnterQueue(SeqQueue *Q,int i)
{
    if((Q->front==Q->rear)&&Q->flag) 
    {
        printf("队满!\n");
        return ;
    }
    else
    {
        Q->data[Q->rear]=i;
        Q->rear=(Q->rear+1)%max;    
        Q->flag=1;
    } 
}

void DeleteQueue(SeqQueue *Q) 
{
    if((Q->flag==Q->rear)&&!Q->flag)
    {
        printf("队列为空\n");
        return;
    }
    else
    {
        Q->front=(Q->front+1)%max;
        Q->flag=0;
    }
}

void PrintQueue(SeqQueue *Q)
{
       if((Q->rear==Q->front)&&!Q->flag)
    {
        printf("队列为空\n");
        return ;
    }
    if(Q->front!=Q->rear&&!Q->flag)
    {
        int i;
        for(i=Q->front;;i=(i+1)%max)
            if(i==Q->rear)
                break;
            else
                printf("%-3d",Q->data[i]);
        printf("\n");
        return;
    }
    else
    {
        for(int i=0;;i=(i+1)%max)
            if(i==Q->rear)
                break;
            else
                printf("%-3d",Q->data[i]);
        printf("\n");
    }
}

int main()
{
    int x;
    SeqQueue Q;
    InitQueue(&Q);
    printf("请输入队列的长度:\n");
    scanf("%d",&x);
    int a[x];
    printf("请输入队列中的元素:\n");
    for(int i=0;i<x;i++)
    {
        scanf("%d",&a[i]);
           EnterQueue(&Q,a[i]);
    }
    DeleteQueue(&Q);
    printf("队列中的元素为:\n");
    PrintQueue(&Q);
    return 0;
}