数据结构-队列

数据结构概念：
数据结构是指数据相互之间存在的一种或多种特定关系的数据元素的集合。
队列：
FIFO：first in first out
队列种类：

• 普通队列
• 环形队列

环形队列

队列

环形队列实现代码：
MyQueue.hpp文件

#ifndef MyQueue_hpp
#define MyQueue_hpp

#include 
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_iQueueLen;
    //队列总容量
    int m_iQueueCapacity;
    //队列头在队列数组中索引
    int m_iHead;
    //队列尾在队列数组中索引
    int m_iTail;
};

#endif /* MyQueue_hpp */

MyQueue.cpp文件

#include "MyQueue.hpp"
#include 
using namespace std;

myQueue::myQueue(int queueCapacity){
    //队列容量赋值
    m_iQueueCapacity = queueCapacity;
    //初始化队列头和队列尾，一开始队列头和队列尾指向同一地址
    m_iHead = 0;
    m_iTail = 0;
    //初始化队列长度，一开始队列长度为0
    m_iQueueLen = 0;
    //根据队列容量创建队列数组
    m_pQueue = new int[queueCapacity];
}

myQueue::~myQueue(){
    //释放队列数组，防止内存溢出
    delete [] m_pQueue;
    m_pQueue = NULL;
}

void myQueue::ClearQueue(){
    m_iHead = 0;
    m_iTail = 0;
    m_iQueueLen = 0;
}

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

bool myQueue::QueueFull() const{
    if (m_iQueueLen == m_iQueueCapacity) {
        return true;
    }else{
        return false;
    }
}

int myQueue::QueueLength() const{
    return m_iQueueLen;
}

bool myQueue::EnQueue(int element){
    if (QueueFull()) {
        return false;
    }else{
        //向队列插入数据
        m_pQueue[m_iTail] = element;
        //队列尾索引加1
        m_iTail++;
        //防止遍历队列时，数组越界
        m_iTail = m_iTail%m_iQueueCapacity;
        //队列长度加1
        m_iQueueLen++;
    }
    return true;
}

bool myQueue::DeQueue(int &element){
    if (QueueEmpty()) {
        return false;
    }else{
        //获取队列头对应的数据，赋值函数外的元素
        element = m_pQueue[m_iHead];
        //队列头索引加1
        m_iHead++;
        //防止遍历队列时，数组越界
        m_iHead = m_iHead%m_iQueueCapacity;
        //队列长度减1
        m_iQueueLen--;
        return true;
    }
}

void myQueue::QueueTraverse(){
    cout << endl;
    //从队列头索引开始遍历，为了遍历所有数据，需要队列长度加上队列头索引
    for (int i = m_iHead; i < m_iQueueLen+m_iHead; i ++) {
        //为防止数组越界，整除队列容量
        cout << m_pQueue[i%m_iQueueCapacity] << endl;
    }
    cout << endl;
}

int *p = new int(5); 和 int *p = new int[5]的区别

int *p = new int(5);
这句是从堆上分配一个int型变量所占的字节内存，这个内存单元存放的整数值为5，然后让一个整形的指针变量p指向它的地址。
释放方式：delete p;
int *p = new int[5];
这句相当于从堆上分配一个含有5个元素的整形数组所占的字节内存，然后让一个整形的指针变量p指向它的首址。
释放方式：delete []p;(注意这个[]不能掉了，如果掉了就会只释放P[0]所占的空间，p[1]到p[4]不会被释放，产生内存泄露。)
int *p = new int(5); 和 int *p = new int[5]的区别

int &p和int p 有什么区别

#include 

void func(int &p,int q){
    int t;
    t=p;
    p=q;
    q=t;
}

int main(int argc, const char * argv[]) {
    int x=1,y=2;
    func(x, y);
    std::cout << x <<"," << y << std::endl;
    return 0;
}

输出结果：2，2

1. 在C++中，函数void func(int &p,int q)中的第一个形式参数p是“int型引用”类型。引用是C++的特殊变量类型，它是已有变量的别名。主调函数调用func把实参传给p时，实际上是给实参起了个别名p，所以在函数中对p的操作就是对主调函数中的对应实参的操作，将会使实参发生永久性改变。而func中的第二个形参int q是普通的int类型，调用时只是将实参的“值”拷贝给q，所以在函数中对q的操作并不影响主调函数中的实参值。
2. int &p这样写，只在作为函数的形式参数时是正确的，若是在声明语句则必须初始化，只有写成int a,&p=a;才是正确的，因为如前所述引用“是已有变量的别名”，所以不可能独立存在。
3. 题面代码在调用func时把x传给了第一个int引用形参p(称为引用传递)，把y传给了第二个普通int形参q(称为值传递或拷贝传递)，函数中语句p=q;把y的值赋给了p，由于p是x的别名，所以使主调函数中x的值变成了y的值2；而q=t;语句虽使函数中的q变量的值变为x原先的值1，但由于q只是y的拷贝，所以并不能影响到主调函数中y变量的值。

数据结构探险—队列篇