【数据结构】队列

---

知识框架

---

队列的顺序存储实现

#include <iostream>
using namespace std;

/**
 * 1. 队列的定义
 */

//1.1 定义
#define MaxSize 10
typedef struct {
    int data[MaxSize]; //静态数组存放队列元素
    int front,rear; //front：队头指针，指向第一个元素，rear：队尾指针，指向下一个要插入的位置
}SeQueue;

//1.2 初始化
void InitQueue(SeQueue &Q){
    //在没有数据的时候 front和rear都为0
    Q.front = 0;
    Q.rear = 0;
}

//1.3 判空
bool QueueEmpty(SeQueue Q){
    return Q.front == Q.rear;
}

//1.4 判满: 牺牲了一个存储单元（rear指向最后元素存储单元时，返回true，而这个存储单元并没有存储数据）
bool FullQueue(SeQueue Q){
    return (Q.rear+1)%MaxSize == Q.front;
}

/**
 * 2. 基本操作
 */


//2.1 入队
bool EnQueue(SeQueue &Q,int e){
    //队满返回false
    if (FullQueue(Q)){
        return false;
    }
    //入队
    Q.data[Q.rear] = e;
    Q.rear = (Q.rear+1)%(MaxSize);
    return true;
}

//2.2出队
bool DeQueue(SeQueue &Q,int &e){
    //队空返回false
    if (QueueEmpty(Q)){
        return false;
    }
    //出队
    e = Q.data[Q.front];
    Q.front = (Q.front+1)%MaxSize;
    return true;


}

//2.3 获得队头元素
bool GetTop(SeQueue Q,int &e){
    if (Q.front == Q.rear){
        return false;
    }
    e = Q.data[Q.front];
    return true;
}

/**
 * 4. 判空 判满的其他方案
 */

// 1. 上面程序
// 判空：rear == front 判满:(rear+1)%MaxSize == front【浪费了一个存储单元】

// 2. 其他不浪费存储单元方案
// 第一种：在定义队列的结构体里面加一个size来统计队列中的数量
// 第二种：在定义队列的结构体里面加一个tag，操作一次入队tag=1，出队tag=0
// 当rear == front究竟是空or满？查看它上一次操作即可，如果是入队（tag=1）导致的相等即满，反之亦然。



int main() {
    //定义
    SeQueue Q;
    InitQueue(Q);

    //入队
    for (int i = 0; ; ++i) {
        if (FullQueue(Q)){
            break;
        }
        EnQueue(Q,i);
    }
    //出队
    int e;
    for (int i = 0;; ++i) {
        if (QueueEmpty(Q)){
            break;
        }
        DeQueue(Q,e);
        cout << e <<"   ";
    }

    cout<<endl;

    return 0;
}

队列的链式存储实现

#include <iostream>
using namespace std;

/**
 * 1. 队列的定义
 */

//1.1 定义
#define MaxSize 10
typedef struct {
    int data[MaxSize]; //静态数组存放队列元素
    int front,rear; //front：队头指针，指向第一个元素，rear：队尾指针，指向下一个要插入的位置
}SeQueue;

//1.2 初始化
void InitQueue(SeQueue &Q){
    //在没有数据的时候 front和rear都为0
    Q.front = 0;
    Q.rear = 0;
}

//1.3 判空
bool QueueEmpty(SeQueue Q){
    return Q.front == Q.rear;
}

//1.4 判满: 牺牲了一个存储单元（rear指向最后元素存储单元时，返回true，而这个存储单元并没有存储数据）
bool FullQueue(SeQueue Q){
    return (Q.rear+1)%MaxSize == Q.front;
}

/**
 * 2. 基本操作
 */


//2.1 入队
bool EnQueue(SeQueue &Q,int e){
    //队满返回false
    if (FullQueue(Q)){
        return false;
    }
    //入队
    Q.data[Q.rear] = e;
    Q.rear = (Q.rear+1)%(MaxSize);
    return true;
}

//2.2出队
bool DeQueue(SeQueue &Q,int &e){
    //队空返回false
    if (QueueEmpty(Q)){
        return false;
    }
    //出队
    e = Q.data[Q.front];
    Q.front = (Q.front+1)%MaxSize;
    return true;


}

//2.3 获得队头元素
bool GetTop(SeQueue Q,int &e){
    if (Q.front == Q.rear){
        return false;
    }
    e = Q.data[Q.front];
    return true;
}

/**
 * 4. 判空 判满的其他方案
 */

// 1. 上面程序
// 判空：rear == front 判满:(rear+1)%MaxSize == front【浪费了一个存储单元】

// 2. 其他不浪费存储单元方案
// 第一种：在定义队列的结构体里面加一个size来统计队列中的数量
// 第二种：在定义队列的结构体里面加一个tag，操作一次入队tag=1，出队tag=0
// 当rear == front究竟是空or满？查看它上一次操作即可，如果是入队（tag=1）导致的相等即满，反之亦然。


/**
 * 链式存储
 */

//1,定义
//链式队列结点
typedef struct LinkNode{
    int data;
    struct LinkNode *next;
}LinkNode;
//链式队列：指向队头和队尾的两个指针
typedef struct {
    LinkNode *front,*rear;
}LinkQueue;

//2.初始化
// 带头结点
void Init(LinkQueue &Q){
    //初始时：front和rear都指向头结点，malloc分配一个头结点
    Q.front=Q.rear=(LinkNode *) malloc(sizeof (LinkNode));
    Q.front->next = NULL;
}
//判空
bool Empty(LinkQueue Q){
    return Q.front == Q.rear;
    //或者 Q.front->next == NULL;
}

//不带头结点
void Init2(LinkQueue &Q){
    Q.front = NULL;
    Q.rear = NULL;
}
//判空
bool Empty2(LinkQueue Q){
    return Q.front == NULL;
}

//3. 入队
//带头结点
bool EnQueue(LinkQueue &Q,int e){
    LinkNode *s = (LinkNode *) malloc(sizeof (LinkNode));
    if (s == NULL){
        return false;
    }
    s->data = e;
    //入队
    s->next = NULL;
    Q.rear->next = s;
    Q.rear = s;
    return true;
}
//不带头结点
bool EnQueue2(LinkQueue &Q,int e){
    LinkNode *s = (LinkNode *) malloc(sizeof (LinkNode));
    if (s == NULL){
        return false;
    }
    s->data = e;
    s->next = NULL;
    //入队
    if (Q.front == NULL){ //第一个节点
        Q.front = s;
        Q.rear = s;
    } else {
        Q.rear->next = s;
        Q.rear = s;
    }

    return true;
}

//4. 出队
//带头结点
bool DeQueue(LinkQueue &Q,int &e){
    if (Q.front->next == NULL){ //队空
        return false;
    }
    LinkNode *p = Q.front->next; //要删除的结点
    Q.front->next = p->next;
    e = p->data;

    //注意！！！如果是最后一个数据结点:需要修改rear指针，指向头结点
    if (Q.rear == p){
        Q.rear = Q.front;
    }

    free(p);
    return true;
}
//不带头结点
bool DeQueue2(LinkQueue &Q,int &e){
    if (Q.front == NULL){ //队空
        return false;
    }
    LinkNode *p = Q.front;
    Q.front = p->next;
    e = p->data;

    if (Q.rear == p){
        Q.rear = NULL;
        Q.front = NULL;
    }
    free(p);
    return true;
}


int main() {
    //定义
    LinkQueue Q;
    Init(Q);

    //入队
    for (int i = 0; i < 8; ++i) {
        EnQueue(Q,i);
    }

    //出队
    int e;
    while (!Empty(Q)){
        DeQueue(Q,e);
        cout<< e << "  ";
    }

    return 0;
}