数据结构之队列

最新推荐文章于 2024-08-10 23:17:45 发布
最新推荐文章于 2024-08-10 23:17:45 发布
阅读量221 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mousing/article/details/63684117
版权

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。


队列特性：先进先出（FIFO)——先进队列的元素先出队列。来源于我们生活中的队列（先排队的先办完事）。

队列有下面几个操作：

  • InitQueue（）　　 ——初始化队列
  • EnQueue（）        ——进队列
  • DeQueue（）        ——出队列
  • IsQueueEmpty（）——判断队列是否为空
  • IsQueueFull（）    ——判断队列是否已满


//
//  Header.h
//  队列
//
//  Created by mouweng on 17/3/19.
//  Copyright © 2017年 队列. All rights reserved.
//

#ifndef Header_h
#define Header_h
#include<iostream>
using namespace std;


class MyQueue
{
public:
    MyQueue(int QueueCapacity);//创建队列
    virtual ~MyQueue();        //销毁队列
    void ClearQueue();         //清空队列
    bool QueueEmpty() const;   //判空队列
    bool QueueFull() const;    //判断为满
    int QueueLength() const;   //返回队列长度
    bool EnQueue(int element); //新队列入队
    bool DeQueue(int &element);//首元素出队
    void QueueTraverse();      //遍历队列
private:
    int *m_pQueue;             //队列数组指针
    int m_iQueueLength;        //队列元素个数
    int m_iQueueCapacity;      //队列数组容量
    int m_iHead;
    int m_iTail;
};

#endif /* Header_h */



我们所知道，队列可以是直行也可以是环形，之所以把队列设成环形的原因呢，是可以节省内存空间。

下面分别给出两种队列的代码


直行队列源码如下：

//
//  Header.h
//  直行队列
//
//  Created by mouweng on 17/3/20.
//  Copyright © 2017年 直行队列. All rights reserved.
//

#ifndef Header_h
#define Header_h

#include<iostream>
using namespace std;


class MyQueue
{
public:
    MyQueue(int QueueCapacity);//创建队列
    virtual ~MyQueue();        //销毁队列
    void ClearQueue();         //清空队列
    bool QueueEmpty() const;   //判空队列
    bool QueueFull() const;    //判断为满
    int QueueLength() const;   //返回队列长度
    bool EnQueue(int element); //新队列入队
    bool DeQueue(int &element);//首元素出队
    void QueueTraverse();      //遍历队列
private:
    int *m_pQueue;             //队列数组指针
    int m_iQueueLength;        //队列元素个数
    int m_iQueueCapacity;      //队列数组容量
    int m_iHead;
    int m_iTail;
};

#endif /* Header_h */


//
//  main.cpp
//  直行队列
//
//  Created by mouweng on 17/3/20.
//  Copyright © 2017年 直行队列. All rights reserved.
//

#include <iostream>
using namespace std;
#include "Header.h"

MyQueue::MyQueue(int QueueCapacity)
{
    m_iQueueCapacity= QueueCapacity;
    m_iHead=0;
    m_iTail=0;
    m_iQueueLength=0;
    m_pQueue=new int[m_iQueueCapacity];
}
MyQueue::~MyQueue()
{
    delete [] m_pQueue;
    m_pQueue=NULL;
}

void MyQueue::ClearQueue()
{
    m_iHead=0;
    m_iTail=0;
    m_iQueueLength=0;
}



bool MyQueue::QueueEmpty() const
{
    if(m_iQueueLength==0)
        return true;
    else
        return false;
}
bool MyQueue::QueueFull() const
{
    if(m_iQueueLength==m_iQueueCapacity)
        return true;
    else
        return false;
}



int MyQueue::QueueLength() const
{
    return m_iQueueLength;
}


bool MyQueue::EnQueue(int element)
{
    if(QueueFull())
    {
        return false;
    }
    else
    {
        m_pQueue[m_iTail]=element;
        m_iTail++;
        m_iQueueLength++;
        return true;
    }
    
}

bool MyQueue::DeQueue(int &element)
{
    if(QueueEmpty())
    {
        return false;
    }
    else
    {
        element = m_pQueue[m_iHead];
        m_iHead++;
        m_iQueueLength--;
        return true;
    }
}

void MyQueue::QueueTraverse()
{
    cout<<endl;
    for(int i=m_iHead;i<m_iTail;i++)
    {
        cout<<m_pQueue[i]<<endl;
    }
    cout<<endl;
}



int main(int argc, const char * argv[])
{
    MyQueue *p=new MyQueue(10);
    
    p->EnQueue(10);
    p->EnQueue(12);
    p->EnQueue(16);
    p->EnQueue(18);
    p->EnQueue(20);
    p->QueueTraverse();
    
    int e=0;
    p->DeQueue(e);
    cout<<e<<endl;
    
    p->DeQueue(e);
    cout<<e<<endl;
    
    p->EnQueue(21);
    p->EnQueue(22);
    p->QueueTraverse();
    
    cout<<endl;
    p->ClearQueue();
    
    p->QueueTraverse();
    
    p->EnQueue(20);
    p->EnQueue(30);
    p->QueueTraverse();
    
    delete p;
    p=NULL;
    return 0;
}



环形队列源码如下：

//
//  main.cpp
//  环形队列
//
//  Created by Anthony on 17/3/19.
//  Copyright © 2017年 队列. All rights reserved.
//

#include <iostream>
using namespace std;
#include "Header.h"

MyQueue::MyQueue(int QueueCapacity)
{
    m_iQueueCapacity= QueueCapacity;
    m_iHead=0;
    m_iTail=0;
    m_iQueueLength=0;
    m_pQueue=new int[m_iQueueCapacity];
}
MyQueue::~MyQueue()
{
    delete [] m_pQueue;
    m_pQueue=NULL;
}

void MyQueue::ClearQueue()
{
    m_iHead=0;
    m_iTail=0;
    m_iQueueLength=0;
}



bool MyQueue::QueueEmpty() const
{
    if(m_iQueueLength==0)
        return true;
    else
        return false;
}
bool MyQueue::QueueFull() const
{
    if(m_iQueueLength==m_iQueueCapacity)
        return true;
    else
        return false;
}



int MyQueue::QueueLength() const
{
    return m_iQueueLength;
}


bool MyQueue::EnQueue(int element)
{
    if(QueueFull())
    {
        return false;
    }
    else
    {
        m_pQueue[m_iTail]=element;
        m_iTail++;
        m_iTail=m_iTail%m_iQueueCapacity;//因为是一个环形队列
        m_iQueueLength++;
        return true;
    }

}

bool MyQueue::DeQueue(int &element)
{
    if(QueueEmpty())
    {
        return false;
    }
    else
    {
        element = m_pQueue[m_iHead];
        m_iHead++;
        m_iHead=m_iHead%m_iQueueCapacity;//因为是一个环形队列
        m_iQueueLength--;
        return true;
    }
}

void MyQueue::QueueTraverse()
{
    cout<<endl;
    for(int i=m_iHead;i<m_iHead+m_iQueueLength;i++)
    {
        cout<<m_pQueue[i%m_iQueueCapacity]<<endl;
    }
    cout<<endl;
}



int main(int argc, const char * argv[])
{
    MyQueue *p=new MyQueue(4);
    
    p->EnQueue(10);
    p->EnQueue(12);
    p->EnQueue(16);
    p->EnQueue(18);
    p->EnQueue(20);
    p->QueueTraverse();
    
    int e=0;
    p->DeQueue(e);
    cout<<e<<endl;
    
    p->DeQueue(e);
    cout<<e<<endl;
    
    p->EnQueue(20);
    p->EnQueue(22);
    p->QueueTraverse();
    
    cout<<endl;
    p->ClearQueue();
    
    p->QueueTraverse();
    
    p->EnQueue(20);
    p->EnQueue(30);
    
    
    
    
    
    
    delete p;
    p=NULL;
    
    
    
    
    return 0;
}



接下来继续给大家延时更加灵活更加节省空间的队列实现方式，是通过链表来粗存队列的元素，为链表队列。

//
//  Header.h
//  链表队列
//
//  Created by mouweng on 17/3/20.
//  Copyright © 2017年 链表队列. All rights reserved.
//

#ifndef Header_h
#define Header_h
#include<iostream>
using namespace std;


class MyQueue
{
public:
    MyQueue();//创建队列
    virtual ~MyQueue();        //销毁队列
    void ClearQueue();         //清空队列
    bool QueueEmpty() const;   //判空队列
    int QueueLength() const;   //返回队列长度
    bool EnQueue(int element); //新队列入队
    bool DeQueue();//首元素出队
    void QueueTraverse();      //遍历队列
private:
    class Node
    {
    public:
        int data;
        Node *next;
        void PrintData()
        {
            cout<<data<<endl;
        }
    };
    Node *m_pQueue;             //队列数组指针
    int m_iQueueLength;        //队列元素个数
    int m_iHead;
    int m_iTail;
};
#endif /* Header_h */


//
//  main.cpp
//  链表队列
//
//  Created by mouweng on 17/3/20.
//  Copyright © 2017年 链表队列. All rights reserved.
//

#include <iostream>
using namespace std;
#include "Header.h"

MyQueue::MyQueue()
{
    m_iHead=0;
    m_iTail=0;
    m_iQueueLength=0;
    m_pQueue=new Node;
    m_pQueue->data=0;
    m_pQueue->next=NULL;
}

MyQueue::~MyQueue()
{
    ClearQueue();
    delete m_pQueue;
}

void MyQueue::ClearQueue()
{
    m_iHead=0;
    m_iTail=0;
    m_iQueueLength=0;
    Node *currentNode=m_pQueue->next;
    while(currentNode!=NULL)
    {
        Node *temp=currentNode->next;
        delete currentNode;
        currentNode= temp;
    }
    m_pQueue->next=NULL;
}



bool MyQueue::QueueEmpty() const
{
    if(m_iQueueLength==0)
        return true;
    else
        return false;
}


int MyQueue::QueueLength() const
{
    return m_iQueueLength;
}


bool MyQueue::EnQueue(int element)
{
    Node *temp=m_pQueue;
    Node *currentNode= new Node;
    if(currentNode==NULL)
        return false;
    currentNode->data=element;
    while(temp->next!=NULL)
        temp=temp->next;
    currentNode->next=temp->next;
    temp->next=currentNode;
    m_iQueueLength++;
    return true;
}

bool MyQueue::DeQueue()
{
    if(QueueEmpty())
    {
        return false;
    }
    else
    {
        Node *temp=m_pQueue;
        for(int i=0;i<m_iQueueLength-1;i++)
            temp=temp->next;
        Node *aftertemp=temp->next;
        temp->next=aftertemp->next;
        delete aftertemp;
        m_iQueueLength--;
        return true;
    }
}

void MyQueue::QueueTraverse()
{
    cout<<endl;
    Node *temp=m_pQueue;
while(temp->next!=NULL)
{
    temp=temp->next;
    temp->PrintData();
}
    cout<<endl;
}



int main(int argc, const char * argv[])
{
    MyQueue *p=new MyQueue();
    
    p->EnQueue(10);
    p->EnQueue(12);
    p->EnQueue(16);
    p->EnQueue(18);
    p->EnQueue(20);
    p->QueueTraverse();
    p->QueueLength();
    
    p->DeQueue();
    p->DeQueue();
    p->QueueTraverse();
    
    p->EnQueue(21);
    p->EnQueue(22);
    p->QueueTraverse();
    
    cout<<endl;
    p->ClearQueue();
    
    p->QueueTraverse();
    
    p->EnQueue(20);
    p->EnQueue(30);
    p->QueueTraverse();
    
    delete p;
    p=NULL;
    return 0;
}







mousing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构之队列的简单定义与使用方法
08-29
Java数据结构之队列的简单定义与使用方法 Java数据结构之队列是计算机科学中的一种基本数据结构，具有先进先出的特点。队列是一种特殊的线性表，元素的添加和删除只能在队列的两端进行，即队头和队尾。Java中实现...
数据结构-使用javascript讲解数据结构之队列.zip
02-12
在这个专题中，我们重点关注的是使用JavaScript语言来讲解的数据结构之一：队列。队列是一种线性数据结构，其操作特性类似于现实生活中的排队等候，遵循“先进先出”（FIFO）的原则。 在JavaScript中，队列可以通过...
【数据结构】—— 队列
最新发布
mist的博客
08-10 1148
队列的链式存储结构，队列的顺序存储结构（循环队列）
数据结构之队列的java实现
12-22
队列也是一种数据结构，类似于栈，只是与栈相反，在队列中先插入的数据也先被移除，即先进先出(FIFO，First In First Out)。队列可以理解成排队，比如，食堂窗口排的队，越在前面的，越早得到服务而先离开。在银行...
数据结构之队列.rar
04-07
这个压缩包文件“数据结构之队列.rar”显然是关于队列数据结构的深入探讨，特别是结合了C++编程语言的应用。 队列的基本概念： 队列是一种线性数据结构，其一端允许元素的插入（称为后端或尾部），另一端允许元素的...
【数据结构之队列系列】队列详解
胡坚涛的博客
01-11 3936
前面我们学习了一种数据结构：栈，栈是一种只允许在一端尽进行插入删除的数据结构，而今天我们将学习另一种数据结构：队列，队列是一种支持在一端进行插入，在另一端进行删除的数据结构。
数据结构 —— 队列（超详细图解 & 接口函数实现）
十里坡小白的博客
08-14 2697
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。数据结构是一种十分优秀的解决实际问题的模板，博主将会用代码结合大量图解，对数据结构进行深度剖析。......
Java实现循环队列数据结构
在Java编程中，循环队列是一种特殊的数据结构，它结合了线性表（如数组或链表）和队列的特性。循环队列克服了传统顺序队列在满时容易出现“假溢出”的问题。在循环队列中，队列的首尾相连形成一个环状，使得队列的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值