队列及其基本操作

目录

队列的定义

队列的实现

队列的基本操作

初始化队列（InitQueue(&Q)）

销毁队列（DestroyQueue(&Q)）

入队（Enqueue(&Q,x)）

出队（DeQueue(&Q,&x)）

读队头元素（GetHead(Q,&x)）

队列中元素的个数（GetNum(Q,&x)）

判空操作（IsEmpty(LinkQueue Q)）

队列的定义

队列是只允许在一端进行插入，在另一端进行删除的线性表。

双端队列：只允许从两端插入、两端删除的线性表。

输入受限的双端队列：只允许一段插入、两端删除的线性表。

输出受限的双端队列：只允许两端插入、一段删除的线性表。

队尾：允许插入的一端叫做队尾，最后一个元素被称为队尾元素。

队头：定义同上。

队列的特点：先进先出（FIFO）

队列的实现

#define MaxSize 10


//顺序表实现队列
typedef struct{
    ElemType data[MaxSize];  //用静态数组存放队列元素
    int front rear;          //队头指针和队尾指针
}SqQueue;

//单链表实现队列
typedef struct LinkNode{     //定义链式队列的节点
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct{             
    LinkNode *front,*rear;   //定义队列的头指针和尾指针
}LinkQueue;

队列的基本操作

初始化队列（InitQueue(&Q)）

//顺序表实现的队列的初始化
void InitQueue(SqQueue &Q){
    Q.rear=Q.front=0;       //初始化时队头、队尾指针指向0
}

//带头结点的队列的初始化
void InitQueue(LinkQueue &Q){
    Q.rear=Q.front=(LinkNode *)malloc(sizeof(LinkNode));  //初始化时front、rear都指 
                                                          //向头节点
    Q.front->next=NULL;
}

//不带头节点的队列的初始化
void InitQueue(LinkQueue &Q){
    Q.front=Q.rear=NULL;
}

销毁队列（DestroyQueue(&Q)）

入队（Enqueue(&Q,x)）

//顺序表实现的队列的入队操作
bool EnQueue(SqQueue &Q,ElemType x){
    if(队满)                         //普通队列Q.rear==MaxSize-1 
                                     //循环队列Q.front==(Q.rear+1)%MaxSize
        return false;
    Q.data[Q.rear]=x;                //将元素x插入队尾
    Q.rear=Q.rear+1;                 //普通队列队尾指针后移
    Q.rear=(Q.rear+1)%MaxSize;       //循环队列队尾指针循环后移
    return true;
}

//带头结点的队列的入队操作
void Enqueue(LinkQueue &Q,ElemType x){
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q.rear->next=s;                                      //新节点插在队尾
    Q.rear=s;                                            //修改队位指针
}

//不带头节点的队列的入队操作
void EnQueue(LinkQueue $Q,Elemtype x){
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    if(Q.front==NULL){                                   //在空队列中插入元素
        Q.front=s;
        Q.rear=s;
    }
    else{                                                //正常插入元素
        Q.rear->next=s;
        Q.rear=s;
    }
}

出队（DeQueue(&Q,&x)）

//顺序表实现的队列的出队操作
bool DeQueue(SqQueue &Q,Elemtype &x){
    if(Q.rear==Q.front)               //普通队列和循环队列的判空一致
        return false;
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;      //队头指针循环后移
    return true;
}

//带头结点的原素的出队操作
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front==Q.rear)
        return false;                 //空队列报错
    LinkNode *p=Q.front->next;
    x=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)                     //若为最后一个元素则修改尾指针
        Q.rear==Q.front;
    free(p);
    return true;
}

读队头元素（GetHead(Q,&x)）

//顺序表实现的队列读取队头元素
bool GetHead(SqQueue Q,ElemType &x){
    if(Q.rear==Q.front)                //队空报错
        return false;
    x=Q.data[Q.front];
    return true;
}

队列中元素的个数（GetNum(Q,&x)）

//顺序表实现的队列队列中的元素的个数
bool GetNum(Q,&x){
    if(Q.rear==Q.front)
        return false;
    x=(Q.rear+MaxSize-front)%MaxSize;
    return true;
}

判空操作（IsEmpty(LinkQueue Q)）

//顺序表和带头节点的单链表实现的队列的判空操作
bool IsEmpty(LinkQueue Q){
    if(Q.front==Q,rear)
        return true;
    else
        return false;
}

//不带头节点的单链表的判空操作
bool IsEmpty(LinkQueue Q){
    if(Q.front==NULL)
        return true;
    else
        return false;
        
}