数据结构与算法——第三章栈和队列（3）

清园暖歌

已于 2022-03-29 00:03:24 修改

阅读量1.1k

点赞数

分类专栏：数据结构与算法文章标签：数据结构算法栈和队列

于 2022-03-28 23:58:25 首次发布

本文链接：https://blog.csdn.net/qq_47941078/article/details/123774059

版权

数据结构与算法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

3.5 队列的表示和操作的实现

3.5 1 相关术语

（1）队列（Queue）是仅在表尾进行插入操作，在表头进行删除操作的线性表。

（2）表尾即an端，称为队尾；表头即a1端，称为队头。

（3）它是一种先进先出（FIFO）的线性表。

3.5.2 队列的抽象数据类型定义

3.5.3 队列的顺序表示和实现

（1）队列的物理存储可以用顺序存储结构，也可用链式存储结构。相应地，队列的存储方式也分为两种，即顺序队列和链式队列。

（2）队列的顺序表示——用一维数组base[MAXQSIZE]

#define MAXQSIZE 100    // 最大队列长度
Typedef struct{
    QElemType *base;    // 初始化的动态分配存储空间
    int front;          // 头指针
    int rear;           // 尾指针
}SqQueue;

受MAXQSIZE限制不能入队了。

假溢出，rear重新指向0地址?

引入循环队列：

模运算：

少用一个元素空间：

循环队列的类型定义：

#define MAXQSIZE 100    // 最大队列长度
Typedef struct{
    QElemType *base;    // 动态分配存储空间
    int front;          // 头指针，若队列不空，指向队列头元素
    int rear;           // 尾指针，若队列不空，指向队列尾元素的下一个位置
}SqQueue;

循环队列的操作：

1. 队列的初始化

Q类型不是指针类型，因为SqQueue前没加*，所以是普通类型，与引用其成员时不用 ->，而用（点）"." 。

Status InitQueue(SqQueue &Q){
    Q.base = new QElemType[MAXQSIZE]    // 分配数组空间
    // c语法
    // Q.base = (QElemType*) malloc(MAXQSIZE*sizeof(QElemType));
    if(!Q.base)
        exit(OVERFLOW);    // 存储分配失败
    Q.front = Q.rear = 0;  // 头指针尾指针置为0，队列为空
    return OK;
}

2. 求队列的长度

3. 循环队列入队

Status EnQueue(SqQueue &Q, QElemType e){
    if((Q.rear+1)%MAXQSIZE == Q.front)
        return ERROR;    // 队满
    Q.base[Q.rear] = e;  // 新元素加入队尾
    Q.rear = (Q.rear+1) % MAXQSIZE;    // 队尾指针+1
    return OK;
}

4. 循环队列出队

Status DeQueue(SqQueue &Q, QElemType e){
    if(Q.rear == Q.front)
        return ERROR;    // 队空
    e = Q.base[Q.front]; // 保存队头元素
    Q.front = (Q.front+1) % MAXQSIZE;    // 队头指针+1
    return OK;
}

5. 取队头元素

SElemType GetHead(SqQueue Q){
    if(Q.front != Q.rear)    // 队列不为空
        return Q.base[Q.front];    // 返回队头指针元素的值，队头指针不变
}

3.5.3 链队——队列的链式表示和实现

链队列的类型定义：

#define MAXQSIZE 100    // 最大队列长度
typedef struct Qnode{
    QElemType data;
    struct Qnode *next;
}QNode, *QuenePtr;

typedef struct {
    QuenePtr front;    // 队头指针
    QuenePtr rear;     // 队尾指针
}LinkQuene;

1. 链队列的初始化

Status InitQuene(LinkQuene &Q){
    Q.front = Q.rear = (QuenePtr) malloc(sizeof(QNode));
    if(!Q.front)
        exit(OVERFLOW);
    Q.front -> next = NULL;
    return OK;
}

2. 销毁链队列

Status DestoryQuene(LinkQuene &Q){
    while(Q.front)
    {
        p = Q.front -> next;
        free(Q.front);
        Q.front = p;
    }
    return OK;
}

3. 将元素e入队

Status EnQuene(LinkQuene &Q, QElemType e){
    p = (QuenePtr) malloc(sizeof(QNode));
    if(!p)
        exit(OVERFLOW);
    p -> data = e;
    p -> next = NULL;
    Q.rear -> next = p;
    Q.rear = p;
    return OK;
}

4. 链队列出队

Status DeQuene(LinkQuene &Q, QElemType &e){
    if(Q.front == Q.rear)
        return ERROR;
    p = Q.front -> next;
    e = p -> data;
    Q.front -> next = p -> next;
    if(Q.rear == p)    // 删除的恰巧是尾结点，所以尾指针也要指向头指针
        Q.rear = Q.front;
    delete p;
    return OK;
}

5. 求链队列的队头元素

Status GetHead(LinkQuene Q, QElemType &e){
    if(Q.front == Q.rear)
        return ERROR;
    e = Q.front -> next -> data;
    return OK;
}