【数据结构】第三章：队列 学习笔记

第三章：队列

特点：先进先出
队尾插入新元素，队头删除元素

3.1 顺序队

类型定义

typedef struct
{
    Elemtype data[Maxsize];
    int front, rear;
}SqQueue;

两个指针：front指向队头元素的前一个位置；
rear指向队尾元素的位置。

队满判断条件：rear=MAXSIZE-1, 此时后面可能还有若干位置不能进入，称为假溢出。改用循环队列。

3.2 循环队列

将顺序队首尾相连。
对于环形队列来说，如果知道队头指针和队列中元素个数，则可以计算出队尾指针。也就是说，可以用队列中元素个数代替队尾指针。

队空条件：front == rear
队满条件：(rear+1)%MaxSize == front
进队e操作：rear = (rear+1)%MaxSize; 将e放在rear处
出队操作：front = (front+1)%MaxSize; 取出front处元素e;

已知front、rear，求队中元素个数count：
　　　count=(rear-front+MaxSize)%MaxSize
已知front、count，求rear：
　　　rear=(front+count)%MaxSize
已知rear、count，求front：
　　　front=(rear-count+MaxSize)%MaxSize

环形队列类型定义

typedef struct
{
    Elemtype data[MAXSIZE];
    int front;
    int count;
}Queue;

初始化循环队列

void InitQueue(Queue* &qu)
{
    qu=(Queue*)malloc(sizeof(Queue));
    qu->front=0;
    qu->count=0;
}

进队

bool EnQueue(Queue* &qu, Elemtype x)
{
    int rear;
    if(qu->count==Maxsize)  return false;
    else 
    {
        rear=(qu->front+qu->count)%Maxsize;     //求出队尾位置
        rear=(rear+1)%Maxsize;      //移动到下一个元素位置
        qu->data[rear]=x;
        qu->count++;
        return true;
    }
}

出队

bool DeQueue(Queue* &qu, Elemtype &x)
{
    if(qu->count==0)    return false;
    else 
    {
        qu->front=(qu->front+1)%Maxsize;
        x=qu->data[qu->front];
        qu->count--;
        return true;
    }
}

判断空队

bool QueueEmpty(QuType *qu)	   //判队空运算算法
{
    return(qu->count==0);
}

3.3 链队

使用不带头结点的单链表实现。
将front 和 rear 指针存储在一个头结点空间内；

类型定义

数据节点：

typedef struct qnode
{
    Elemtype data;
    struct qnode *next;
}DataNode;

头节点：

typedef struct
{
    DataNode *front;
    DataNode *rear;
}LinkquNode;

队空条件：front=rear=NULL
队满条件：不考虑
进队e操作：将包含e的结点插入到单链表表尾
出队操作：删除单链表首数据结点

初始化链队

只创建头结点

void InitQueue(LinkquNode* &q)
{
    q=(LinkquNode*)malloc(sizeof(LinkquNode));
    q->front=q->rear=NULL;
}

销毁链队

void DestroyQueue(LinkquNode* &q)
{
    DataNode *p=q->front, *r;
    if(p!=NULL)
    {
        r=p->next;
        while(r!=NULL)
        {
            free(p);
            p=r;
            r=p->next;
        }
    }
    free(p); free(q);
}

判断空链队

bool QueueEmpty(LinkquNode *q)
{
    return (q->rear==NULL);
}

进队

void enQueue(LinkquNode* &q, Elemtype e)
{
    DataNode *p;
    p=(DataNode*)malloc(sizeof(DataNode));
    p->data=e;
    p->next=NULL;

    if(q->rear==NULL)
    {
        q->front=p;
        q->rear=p;
    }
    else
    {
        q->rear->next=p;        //更改队尾位置，连接上一个队尾
        q->rear=p;
    }
}

出队

bool deQueue(LinkquNode* &q, Elemtype &e)
{
    DataNode *t;
    if(q->rear==NULL)   return false;   //空队列
    t=q->front;

    if(q->front==q->rear)   //只有一个结点
    {
        q->front=q->rear=NULL;
    }  
    else    //有多个结点
    {
        q->front=q->front->next;
    }
    e=t->data;
    free(t);
    return true;
}