数据结构之队列

1.顺序队列

代码实现

#include<iostream>
using namespace std;
#define Maxsize 10//定义队列中元素的最大个数
typedef struct 
{
    int data[Maxsize];
    int front,rear;//队头队尾指针
}SqQueue;

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

bool QueueEmpty(SqQueue Q){
    if(Q.front==Q.rear){//对空条件
        return true;
    }
    else{
        return false;
    }
}

//入队
bool EnQueue(SqQueue&Q,int x){
    if(Q.rear-Q.front==Maxsize){//队列已满
        return false;
    }
    Q.data[Q.rear]=x;
    Q.rear++;
    return true;
}
//出队
bool DeQueue(SqQueue& Q, int& x) {  
    if (Q.front == Q.rear) { // 队列已空  
        return false;  
    }  
    x = Q.data[Q.front]; 
    Q.front = Q.front + 1;  
    return true;  
}

int main(){
    SqQueue Q;
    InitQueue(Q);
    EnQueue(Q,2);
    EnQueue(Q,8);
    EnQueue(Q,5);
    
    int x=0;
    DeQueue(Q,x);
    cout<<"出队元素为："<<x<<endl;
    return 0;
}

2. 顺序存储实现的循环队列

代码实现

#include<iostream>
using namespace std;
#define Maxsize 10//定义队列中元素的最大个数
typedef struct 
{
    int data[Maxsize];
    int front,rear;//队头队尾指针
}SqQueue;

void InitQueue(SqQueue &Q){
    Q.front=Q.rear=0;//由于是循环队列现在初始化可以不为0
}

//队列是否空
bool QueueEmpty(SqQueue Q){
    if(Q.front==Q.rear){//对空条件还是不变
        return true;
    }
    else{
        return false;
    }
}

//队列是否满
bool QueueFull(SqQueue Q)
{
    if ((Q.rear + 1) % Maxsize == Q.front)
        return false;
    else
        return true;
}

//入队
bool EnQueue(SqQueue&Q,int x){
    if((Q.rear+1)%Maxsize==Q.front){//队列已满
        return false;
    }
    Q.data[Q.rear]=x;  
    Q.rear=(Q.rear+1)%Maxsize;//更新rear指针,可能初始时front不是从0开始
    return true;
}

//出队
bool DeQueue(SqQueue& Q, int& x) {  
    if (Q.front == Q.rear) { // 队列已空  
        return false;  
    }  
    x = Q.data[Q.front]; 
     Q.front = (Q.front + 1) % Maxsize; // 更新 front 指针  
    return true;  
}

//获取队头元素
bool Getelem(SqQueue& Q, int& x) {  
    if (Q.front == Q.rear) { // 队列已空  
        return false;  
    }  
    x = Q.data[Q.front]; 
    return true;  
}

//获取队列元素的个数
int getnum(SqQueue Q){
    return (Q.rear+Maxsize-Q.front)%Maxsize;
}

int main(){
    SqQueue Q;
    InitQueue(Q);
    EnQueue(Q,2);
    EnQueue(Q,8);
    EnQueue(Q,5);
    
    int y=getnum(Q);
    cout<<"队列中元素的个数为： "<<y<<endl;

    int x=0;
    DeQueue(Q,x);
    cout<<"出队元素为： "<<x<<endl;

      y=getnum(Q);
    cout<<"现在队列中元素的个数为： "<<y<<endl;
    return 0;
}

注意：上述这种方法是基于牺牲一个单元来区分队列满还是队列空，还有两种方法这里不讨论，可以看看onenote

3.链式队列

代码

#include<iostream>
using namespace std;
//带头结点
typedef struct Linknode//链式队列节点
{
    int data;
    struct Linknode *next;
}Linknode;

typedef struct //链式队列
{
 Linknode *front,*rear;
}LinkQueue;

//初始化队列（带头结点）
void InitQueue(LinkQueue &Q){
    Q.front=Q.rear=(Linknode*)malloc(sizeof(Linknode));
    Q.front->next=NULL;//头节点next域为空
}

//判断队列是否为空（带头结点）
bool QueueEmpty(LinkQueue Q){
    if(Q.front==Q.rear){
        return true;
    }
    else{
        return false;
    }
}

//入队（带头结点）
bool EnQueue(LinkQueue &Q,int x){
    Linknode *s=(Linknode*)malloc(sizeof(Linknode));
    s->data=x;
    s->next=NULL;
    Q.rear->next=s;//新节点插入到头节点之后
    Q.rear=s;//rear继续指向表尾
    return true;

}

//出队（带头节点）
bool DeQueue(LinkQueue &Q,int &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;//将rear指向头节点
    }
    free(p);
    return true;
    
       
}

//带头结点
void test01(){
        LinkQueue Q;
    InitQueue(Q);
    EnQueue(Q,2);
    EnQueue(Q,8);
    EnQueue(Q,5);
    int x=0;
    DeQueue(Q,x);
    cout<<"带头节点的出队元素为： "<<x<<endl;
}

//初始化队列（不带头结点）
void InitQueue1(LinkQueue &Q){
    Q.front=Q.rear=NULL;

}

//判断队列是否为空（不带头结点）
bool QueueEmpty1(LinkQueue Q){
    if(Q.front==NULL){
        return true;
    }
    else{
        return false;
    }
}
//入队（不带头节点）
void EnQueue1(LinkQueue &Q,int x){
    Linknode *s=(Linknode*)malloc(sizeof(Linknode));
    s->data=x;
    s->next=NULL;
    if(Q.front==NULL){//在空队列中插入第一个元素,注意这里不能Q.front==Q.rear判断
        Q.front=s;
        Q.rear=s;
    }
    else{
        Q.rear->next=s;//新节点插入到rear之后
        Q.rear=s;//rear继续指向表尾
    }
}
//出队（不带头节点）
bool DeQueue1(LinkQueue &Q,int &x){
    if(Q.front==NULL){//队列空
            return false;
        }
    Linknode*p=Q.front;//指向队头元素
    x=p->data;
    Q.front=p->next;//把队头元素踢出
    if(Q.rear==p){//对列最后一个节点出队要特殊处理
        Q.rear=Q.front=NULL;
    }
    free(p);
    return true;
    
       
}

//带头结点
void test02(){
    LinkQueue Q;
    InitQueue1(Q);
    EnQueue1(Q,5);
    EnQueue1(Q,8);
    EnQueue1(Q,5);
    int x=0;
    DeQueue1(Q,x);
    cout<<"不带头节点的出队元素为： "<<x<<endl;
}

int main(){
    //带头节点的
    test01();
    //不带头节点的
    test02();
    return 0;
}

4.双端队列

这里只要求会做题，代码偷懒了，hh

#include <iostream>
#include <deque>
#include <string>
using namespace std;

int main()
{
    deque<string> q;
    q.push_back("world");//尾部入队                                                                     
    cout << "将'world'入队后队尾为: " << q.back() << endl; 

    q.push_front("Hello"); //头部入队                                                                 
    cout << "将'Hello'入队后队头为: " << q.front() << endl;         
    cout << "此时队列的尾部元素: " << q.back() << endl;  

    q.push_back("!");                                                                        
    q.pop_front(); //头部出队                                                                          
    cout << "删除队列头部元素后，新队列的头部元素: " << q.front() << endl;             
    // empty()返回bool值，表示队列是否为空，此时不为空，返回0      
    cout << "队列是否为空: " << q.empty() << endl; 
    
    q.pop_back();                                                                             
    cout << "又删除了队尾元素'!',现在队列是否为空: " << q.empty() << endl; 
    cout << "此时队列的大小: " << q.size() << endl;                                        
    return 0;
}

5.队列应用