数据结构之队列篇

队列原理

先入先出FIFO:first in first out

普通队列：

1. 有个数限制
2. 队列头处理删除，若后续成员不向前一个移动则浪费内存，若移动效率低速度慢。
   

环形队列：

队列结构的面向对象设计

class MyQueue{
    public:
        MyQueue(int queueCapacity); //创建队列 InitQueue(&Q)
        virtual ~MyQueue();  //DestroyQueue(&Q) 销毁队列
        void ClearQueue(); //ClearQueue(&Q) 清空队列
        bool QueueEmpty() const; //QueueEmpty(Q) 判空队列
        bool QueueFull() const; //判满队列 
        int QueueLength() const; //QueueLength(Q) 队列长度
        bool EnQueue(int element); //EnQueue(&Q, element) 新元素入队
        bool DeQueue(int &element); // DeQueue(&Q，&element) 首元素出队
        void QueueTraverse(); //QueueTraverse(Q, visit()) 遍历队列
    private:
        int *m_pQueue;  // 队列数组指针 
        int m_iQueueLen;  //队列元素个数 
        int m_iQueueCapacity;  //队列数组容量 
}; 

环形队列代码实现

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

MyQueue::MyQueue(int queueCapacity) {
    m_iQueueCapacity = queueCapacity;
    m_pQueue = new int[m_iQueueCapacity];
    ClearQueue();
}
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;
       m_iTail += 1;
       m_iTail = m_iTail % m_iQueueCapacity;
       m_iQueueLen++;
       return true;
    }
}
bool MyQueue::DeQueue(int &element) {
    if(QueueEmpty()){
        return false;
    } else {
       element = m_pQueue[m_iHead];
       m_iHead += 1; 
       m_iHead = m_iHead % m_iQueueCapacity;
       m_iQueueLen--;
       return true;
    }
}
void MyQueue::QueueTraverse() {
    for(int i = m_iHead; i < m_iQueueLen; i++) {
        cout << m_pQueue[i % m_iQueueLen] << endl;
    }
}

环形队列实现检测

#include<iostream>
#include<stdlib.h>
#include"MyQueue.h"
int main(){
    MyQueue *p = new MyQueue(4);//当前队列中可最多容纳4个元素
    p->EnQueue(10);
    p->EnQueue(12);
    p->EnQueue(19);
    p->EnQueue(90);
    p->QueueTraverse();
    int e = 0;
    p->DeQueue(e);
    cout << endl;
    cout << e << endl;
    
    p->DeQueue(e);
    cout << endl;
    cout << e << endl;
    
    cout << endl;
    p->QueueTraverse();
    
    p->ClearQueue();
    p->QueueTraverse();
    delete p;
    p = NULL;
  
    return 0;
}

运行结果：