队列C++实现

最新推荐文章于 2024-04-28 18:45:35 发布

原创最新推荐文章于 2024-04-28 18:45:35 发布 · 1.2k 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #链表 #数据结构

基本概念

定义

一种操作受限的线性表，只允许在表的一段进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。最早排队的也是最早离队的，操作的特性就是先进先出，也就是FIFO。

队头(Front)。允许删除的一端，又称为队首。

队尾(Rear)。允许插入的一端。

空队列。不凡任何元素的空表。

队列常见的基本操作

InitQueue (&Q); 初始化队列，构造一个空队列Q

QueueEmpty(Q); 判断列空，若队列Q为空返回true，否则返回false

EnQueue (&Q , x); 入队，若队列Q未满，将x加入，使之成为新的队尾

DeQueue (&Q , &x); 出队，若队列Q非空，删除队头元素，并用x返回

GetHead (Q , &x); 读取队头元素，若队列Q非空，则将队头元素赋值给x

注：栈和队列是操作受限的线性表，因此不是任何对线性表的操作都可以作为栈和队列的操作。比如，如可以随便读取栈或队列中间的某个数据。

队列的顺序存储结构

存储类型描述以及基本操作的代码如下：

//
// Created by PrimeChuJiang on 2022/11/22.
//
#include <iostream>

#define Maxsize 50

using namespace std;

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

void InitQueue(SqQueue &Q){
    Q.front = 0;
    Q.rear = 0;
}

bool QueueEmpty(SqQueue Q){
    return Q.rear == Q.front;
}

bool QueueOverflow(SqQueue Q){
    return (Q.rear+1)%Maxsize == Q.front;
}

void EnQueue(SqQueue &Q , int x){
    if (QueueOverflow(Q)) {
        cout<<"WARNING: List is full!"<<endl;
        return;
    }
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear+1)%Maxsize;
}

void DeQueue(SqQueue &Q , int & x){
    if (QueueEmpty(Q)){
        cout<<"WARNING：List is empty!"<<endl;
        return;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front+1)%Maxsize;
}

void GetHead (SqQueue Q , int &x){
    x = Q.data[Q.front];
}

int main(){
    SqQueue Q;
    int x;
    bool flag;
    InitQueue(Q);
    flag = QueueEmpty(Q);
    EnQueue(Q,1);
    GetHead(Q,x);
    EnQueue(Q,2);
    EnQueue(Q,3);
    EnQueue(Q,4);
    EnQueue(Q,5);
    EnQueue(Q,6);
    GetHead(Q,x);
    flag = QueueEmpty(Q);
    DeQueue(Q,x);
    cout<<x<<endl;
    DeQueue(Q,x);
    cout<<x<<endl;
    DeQueue(Q,x);
    cout<<x<<endl;
    DeQueue(Q,x);
    cout<<x<<endl;
    DeQueue(Q,x);
    cout<<x<<endl;
    DeQueue(Q,x);c
    cout<<x<<endl;
}

队列的链式存储结构

存储类型描述以及基本操作的代码如下：

//
// Created by Administrator on 2022/11/22.
//
#include <cstring>

using namespace std;

typedef struct LNode{
    int data;
    struct LNode * next;
}LNode;

typedef struct LinkQueue{
    LNode * rear;
    LNode * front;
}LinkQueue;

void InitQueue(LinkQueue & Q){
    Q.rear = Q.front = new LNode ;
}

bool QueueEmpty(LinkQueue &Q){
    return Q.front == Q.rear;
}

//链式存储不存在上溢问题，就不用QueueOverflow函数

void EnQueue(LinkQueue &Q , int x){
    auto * s = new LNode ;
    s->data = x;
    s->next = Q.rear->next;
    Q.rear->next = s;
    Q.rear = s;
}

void DeQueue(LinkQueue &Q , int & x){
    LNode * p = Q.front->next;
    Q.front->next = p->next;
    x = p->data;
    if(p==Q.rear){
        Q.rear = Q.front;
    }
    operator delete(p);
}

void GetHead (LinkQueue Q , int &x){
    x = Q.rear->data;
}
c
int main (){

}