队列：先进先出，就如排队一样，先到的，先排上

1.链式队列

1.1 头文件 listQueue.h

/*** @description: 链式队列* @author: michael ming* @date: 2019/4/1 22:47* @modified by:*/#ifndef QUEUE_LISTQUEUE_H
#define QUEUE_LISTQUEUE_H
template <class T>
struct SNode
{T data;SNode* pNext;
};typedef unsigned int UINT;
template <class T>
class ListQueue
{public:ListQueue(void);~ListQueue(void);bool enqueue(const T& data);  //入队    从队列的尾部插入数据bool dequeue();     //出队   从队列的头部弹出数据UINT getlength() const;    //获得队列的长度bool empty() const;        //判断队列是否为空void erase();     //清空队列void print() const;       //打印队列SNode<T>* getHead();    //获取队首SNode<T>* getTail();    //获取队尾
private:SNode<T>* m_pHead;SNode<T>* m_pTail;UINT m_QueueLen;
};#include "listQueue.cpp"
#endif //QUEUE_LISTQUEUE_H

1.2 类实现文件 listQueue.cpp

/*** @description: 链式队列实现文件* @author: michael ming* @date: 2019/4/1 22:47* @modified by:*/
//#include "listQueue.h"
#include <iostream>
using namespace std;
template <class T>
ListQueue<T>::ListQueue():m_pHead(NULL),m_pTail(NULL),m_QueueLen(0){}
template <class T>
ListQueue<T>::~ListQueue()
{erase();
}
template <class T>
inline void ListQueue<T>::erase()
{SNode<T>* temp;while(m_pHead != NULL){temp = m_pHead->pNext;delete m_pHead;m_pHead = temp;}m_pTail = NULL;m_QueueLen = 0;
}
template <class T>
bool ListQueue<T>::empty() const
{return m_pHead == NULL;
}
template <class T>
UINT ListQueue<T>::getlength() const
{return m_QueueLen;
}
template <class T>
bool ListQueue<T>::enqueue(const T &data)
{SNode<T>* newNode = new SNode<T>;newNode->data = data;newNode->pNext = NULL;if(m_pTail == NULL)m_pHead = m_pTail = newNode;else{m_pTail->pNext = newNode;m_pTail = newNode;}m_QueueLen++;return true;
}
template <class T>
bool ListQueue<T>::dequeue()
{if(m_pHead != NULL){SNode<T>* temp = m_pHead;m_pHead = m_pHead->pNext;if(m_pHead == NULL)m_pTail == NULL;delete temp;m_QueueLen--;return true;}return false;
}
template <class T>
void ListQueue<T>::print() const
{cout << "-------------------------------------------" << endl;cout << "List Queue from head to tail as follow: " << endl;SNode<T>* temp = m_pHead;   int i = 0;while(temp != NULL){cout << "No." << ++i << " elem is " << temp->data << endl;temp = temp->pNext;}
}
template <class T>
SNode<T>* ListQueue<T>::getHead()
{return m_pHead;
}
template <class T>
SNode<T>* ListQueue<T>::getTail()
{return m_pTail;
}

1.3 测试主函数 listqueue_main.cpp

/*** @description:* @author: michael ming* @date: 2019/4/1 22:49* @modified by:*/
#include "listQueue.h"
#include <iostream>
int main()
{ListQueue<int> intqueue;int k = 5;for(int i = 0; i < k; ++i){intqueue.enqueue(i);}intqueue.print();std::cout << "len of queue is " << intqueue.getlength() << std::endl;for(int i = 0; i < k-1; ++i){intqueue.dequeue();std::cout << "after one dequeue: " << std::endl;intqueue.print();}std::cout << "len of queue is " << intqueue.getlength() << std::endl;std::cout << "head is " << intqueue.getHead()->data << std::endl;std::cout << "tail is " << intqueue.getTail()->data << std::endl;return 0;
}

1.4 valgrind测试运行结果

2. 顺序队列

基于数组实现，有容量限制

2.1 头文件 arrqueue.h

/*** @description: 顺序队列，内部基于数组* @author: michael ming* @date: 2019/4/2 21:24* @modified by:*/
#ifndef QUEUE_ARRQUEUE_H
#define QUEUE_ARRQUEUE_H
typedef unsigned int UINT;
template <class T>
class arrQueue
{public:arrQueue(const int capa = 10);~arrQueue(void);bool enqueue(const T& data);  //入队    从队列的尾部插入数据bool dequeue();       //出队   从队列的头部弹出数据UINT getlength() const;    //获得队列的长度bool empty() const;        //判断队列是否为空bool full() const;      //判断队列是否满void erase();        //清空队列void print() const;       //打印队列const T& getHead() const;    //获取队首const T& getTail() const;    //获取队尾
private:int m_pHead;int m_pTail;UINT m_QueueLen;UINT m_capacity;T* arrQ;
};#include "arrqueue.cpp"
#endif //QUEUE_ARRQUEUE_H

2.2 类实现文件 arrqueue.cpp

/*** @description: 顺序队列实现文件* @author: michael ming* @date: 2019/4/2 21:26* @modified by:*/
#include <iostream>
using namespace std;
template <class T>
arrQueue<T>::arrQueue(const int capa):m_pHead(0),m_pTail(-1),m_QueueLen(0),m_capacity(capa)
{arrQ = new T[m_capacity];
}
template <class T>
arrQueue<T>::~arrQueue()
{erase();delete [] arrQ;
}
template <class T>
inline void arrQueue<T>::erase()
{m_QueueLen = 0;m_pHead = 0;m_pTail = -1;
}
template <class T>
bool arrQueue<T>::empty() const
{return m_QueueLen == 0;
}
template <class T>
bool arrQueue<T>::full() const
{return m_QueueLen == m_capacity;
}
template <class T>
bool arrQueue<T>::enqueue(const T &data)
{if(full())return false;else{if(empty()){m_pHead = m_pTail = 0;arrQ[0] = data;m_QueueLen++;}else if(m_pTail < m_capacity-1){arrQ[++m_pTail] = data;m_QueueLen++;}else    //队列没满，但是队尾到达数组末尾了，数据整体移至数组头部{for(UINT i = 0; i < m_QueueLen; ++i){arrQ[i] = arrQ[m_pHead++];}m_pHead = 0;arrQ[m_QueueLen++] = data;m_pTail = m_QueueLen - 1;}return true;}
}
template <class T>
bool arrQueue<T>::dequeue()
{if(empty())return false;else{m_pHead++;m_QueueLen--;if(m_QueueLen == 0){m_pHead = 0;m_pTail = -1;}return true;}
}
template <class T>
UINT arrQueue<T>::getlength() const
{return m_QueueLen;
}
template <class T>
const T& arrQueue<T>::getHead() const
{return arrQ[m_pHead];
}
template <class T>
const T& arrQueue<T>::getTail() const
{return arrQ[m_pTail];
}
template <class T>
void arrQueue<T>::print() const
{if(empty())cout << "empty queue!" << endl;cout << "arrQueue from head to tail as follow:" << endl;int j = m_pHead;for(UINT i = 0; i < m_QueueLen; ){cout << "No." << ++i << " elem is " << arrQ[j++] << endl;}cout << "--------------print end----------------" << endl;
}

2.3 测试主程序 arrqueue_main.cpp

/*** @description:* @author: mingm* @date: 2019/4/1 22:44* @param:* @return:*/
#include <iostream>
#include "arrqueue.h"
int main()
{arrQueue<int> intqueue(7);for(UINT i = 0; i < 8; ++i){intqueue.enqueue(i);intqueue.print();}for(UINT i = 0; i < 5; ++i){intqueue.dequeue();intqueue.print();}intqueue.enqueue(100);intqueue.print();cout << "the length of queue is " << intqueue.getlength() << endl;cout << "head is " << intqueue.getHead() << ", tail is " << intqueue.getTail() << endl;return 0;
}

2.4 valgrind测试结果正确

数据结构--队列Queue--链式队列、顺序队列相关推荐

队列，链队列，链式存储的队列
采用链式存储的队列称为链队列(linked queue),队列是运算受限的线性表,即队列的插入和删除位置分别位于表的两端.故需要两个指针来指向这2个特殊位置,即对首指针和队尾指针. 本例采用的是带头结 ...
数据结构之顺序队列和链式队列常用的一些操作
顺序队列是队列的顺序存储结构,顺序队列实际上是运算受限的顺序表.和顺序表一样,顺序队列用一个向量空间来存放当前队列中的元素.由于队列的队头和队尾的位置是变化的,设置两个指针front和rear分别指示 ...
队列的链式存储结构及其实现_了解队列数据结构及其实现
队列的链式存储结构及其实现 A queue is a collection of items whereby its operations work in a FIFO - First In Firs ...
c语言建立队列（顺序队列、循化队列和链式队列）
c语言建立队列一.顺序队列队列的顺序存储结构顺序队列的讨论 "下溢"现象 "真上溢"现象 "假上溢"现象二.如何解决"假上 ...
数据结构 3-2-1 队列的链式存储实现
一.概念队列也是一种受限的线性表,只允许一端插入另一段输出,就像其名字一样,队列具有先入先出的特点,这是由于其受限的特点所决定的.用链式结构实现队列,称为链队列,实际上是一个带有队头指针和队尾指针的 ...
队列的链式存储和实现（C语言）【队列】（8）
LinkQueue.h DataType.h DataType.cpp LinkQueue.cpp 测试结果 LinkQueue.h #pragma once#include "DataTy ...
队列的链式存储结构及实现
队列的链式存储结构,其实就是线性表的单链表,只不过它只是尾进头出而已,我们把它简称为链队列.为了操作上的方便,我们将队头指针指向链队列的头结点,而队尾指针指向终端节点.如果空队列时,front和re ...
队列的链式存储实现（简单的入队和出队操作）
/************************************************************************ * * 文件名:2.2.5.cpp * * 文件描述 ...
队列的链式存储结构（链队）
链队 1.队列的链式存储结构 typedef struct QNode{ //结点结构QElemType data; //结点数据域struct QNode *next; //结点指针域 }QNode ...
c语言队列（顺序队列，循环队列，链式队列）
顺序队列 1.初始化: front=-1; rear=-1; 2.判空条件 font=rear; 3.队列已满条件 rear=max-1; 代码: #include<stdio.h> #i ...

数据结构--队列Queue--链式队列、顺序队列

1.链式队列

1.1 头文件 listQueue.h

1.2 类实现文件 listQueue.cpp

1.3 测试主函数 listqueue_main.cpp

1.4 valgrind测试运行结果

2. 顺序队列

2.1 头文件 arrqueue.h

2.2 类实现文件 arrqueue.cpp

2.3 测试主程序 arrqueue_main.cpp

2.4 valgrind测试结果正确

数据结构--队列Queue--链式队列、顺序队列相关推荐

最新文章

热门文章