链接借助前面的双循环链表实现
#ifndef QUEUE_HPP
#define QUEUE_HPP
#include <iostream>
#include "exceptions.hpp"
template <typename T>
class Queue
{
public:
Queue(){}
virtual ~Queue() {}
/**
* @brief dequeue 出队
* @return
*/
virtual T dequeue() = 0;
/**
* @brief enqueue 入队
* @param t
*/
virtual void enqueue(const T& t) = 0;
/**
* @brief isEmpty 队空
* @return
*/
virtual bool isEmpty() const = 0;
/**
* @brief traverse 遍历
* @param s 分割符
* @param os 输出流
*/
virtual void traverse(const std::string &s, std::ostream &os) const = 0;
virtual int length() const = 0;
// virtual int capacity() const = 0;
virtual void clear() = 0;
};
#endif // QUEUE_HPP
#ifndef CIRCULARSEQQUEUE_HPP
#define CIRCULARSEQQUEUE_HPP
#include "queue.hpp"
template <typename T>
/**
* @brief The CircularSeqQueue class 循环队列
*/
class CircularSeqQueue : public Queue<T>
{
public:
CircularSeqQueue(int _size = DEFAULTSIZE);
~CircularSeqQueue();
int length() const;
T dequeue();
void enqueue(const T &t);
bool isEmpty() const;
bool isFull() const;
void traverse(const std::string &s = std::string(), std::ostream &os = std::cout) const;
/**
* @brief capacity 顺序实现时的数组的长度
* @return
*/
int capacity() const {
return size;
}
void clear();
private:
enum {DEFAULTSIZE = 10};
int size;
int front;
int tail;
T *d_p;
};
template <typename T>
inline
CircularSeqQueue<T>::CircularSeqQueue(int _size):
size(_size+1),//循环队列有一个为空,来实现空队和满队的区别
front(0),
tail(0)
{
d_p = new T[size];
}
template <typename T>
CircularSeqQueue<T>::~CircularSeqQueue()
{
delete[] d_p;
}
template <typename T>
inline
bool CircularSeqQueue<T>::isEmpty() const
{
return front == tail;
}
template <typename T>
inline
bool CircularSeqQueue<T>::isFull() const
{
return (tail+1)%size == front;
}
template <typename T>
inline
int CircularSeqQueue<T>::length() const
{
return (tail - front + size) % size;
}
template <typename T>
void CircularSeqQueue<T>::enqueue(const T &t)
{
if (isFull()) throw OutOfBoundary();
tail = (tail+1) % size;
d_p[tail] = t;
}
template <typename T>
T CircularSeqQueue<T>::dequeue()
{
if (isEmpty()) throw OutOfBoundary();
front = (front+1) % size;
return d_p[front];
}
template <typename T>
inline
void CircularSeqQueue<T>::clear()
{
front = tail = 0;
}
template <typename T>
void CircularSeqQueue<T>::traverse(const std::string &s, std::ostream &os) const
{
if (tail >= front) {
for (int i = front+1;i <= tail;++i) {
os << d_p[i] << s;
}
} else {
for (int i = front+1;i < size;++i) {
os << d_p[i] << s;
}
for (int i = 0;i <= tail;++i) {
os << d_p[i] << s;
}
}
}
#endif // CIRCULARSEQQUEUE_HPP
#ifndef LINKQUEUE_HPP
#define LINKQUEUE_HPP
#include "queue.hpp"
#include "linkList.hpp"
template <typename T>
/**
* @brief The LinkQueue class 链队
*/
class LinkQueue : public Queue<T>
{
public:
LinkQueue();
~LinkQueue();
void enqueue(const T &t);
T dequeue();
int length() const {
return queue.length();
}
bool isEmpty() const;
void clear();
void traverse(const std::string &s = std::string(), std::ostream &os = std::cout) const;
private:
LinkList<T> queue;//借助双循环链表实现
};
template <typename T>
inline
LinkQueue<T>::LinkQueue()
{
}
template <typename T>
LinkQueue<T>::~LinkQueue()
{
}
template <typename T>
inline
bool LinkQueue<T>::isEmpty() const
{
return queue.length() == 0;
}
template <typename T>
/**
* @brief LinkQueue<T>::enqueue 入队
* @param t
*/
void LinkQueue<T>::enqueue(const T &t)
{
queue.push_tail(t);
}
template <typename T>
/**
* @brief LinkQueue<T>::dequeue 出队
* @return
*/
T LinkQueue<T>::dequeue()
{
return queue.pop_front();
}
template <typename T>
void LinkQueue<T>::clear()
{
queue.clear();
}
template <typename T>
void LinkQueue<T>::traverse(const std::string &/*s*/, std::ostream &os) const
{
queue.traverse(os);//链表的没加分割符
}
#endif // LINKQUEUE_HPP