循环队列----链式队列-双端队列---复习

解决该问题
循环队列
顺序存储

#pragma once
#include<iostream>
using namespace std;
//循环队列
template <class T>
class SeqQueue {
protected:
	int rear, front; //队尾和队头指针
	T* elements;
	int maxSize;
public:
	SeqQueue() {
		maxSize = 100;
		elements = new T[maxSize];
		 rear = front = 0; //注意初始化条件
	};
	SeqQueue(int sz);
	~SeqQueue() { delete[]elements; }
	bool EnQueue(const T& x);
	bool DeQueue(T& x);
	bool getFront(T& x);
	void makeEmpty() { front = rear = -1; }
	bool IsEmpty()const { return front == rear; }
	bool IsFull()const {
		return ((rear + 1) % maxSize == front);
	}
	int getSize()const
	{
		return (rear - front + maxSize) % maxSize;
	}
};
//循环队列
template <class T>  //构造函数
SeqQueue<T>::SeqQueue(int sz)
{
	maxSize = 100;
	while (sz > maxSize)
	{
		cout << "范围超过，请重新输入" << endl;
		cin >> sz;
	}
	elements = new T[sz];
	rear = front = 0;   //循环队列，初始位置为0，front占一个空间。
}
template <class T>// 入队
bool SeqQueue<T>::EnQueue(const T& x)
{
	if ((rear + 1) % maxSize == front)
	{
		cout << "overflow" << endl;
		return false;
	}
	else
	{
		rear = (rear + 1) % maxSize;
		elements[rear] = x;  //填入新元素
		return true;
	}
}
template <class T>// 出队
bool SeqQueue<T>::DeQueue(T &x)
{
	if (front == rear)
	{
		cout << "underflow" << endl;
		return false;
	}
	else
	{
	front = (front + 1) % maxSize;
		x = elements[front];
		
		return true;
	}
}

template <class T>// 出队
bool SeqQueue<T>::getFront(T& x)
{
	if (front == rear)
	{
		cout << "empty" << endl;
	}
	else
	{
	   front =(front+1)%maxSize;
		x = elements[front];
		return true;
	}
}

链式队列

#include <iostream>
#include <cassert>
using namespace std;

template <typename T>
struct LinkNode{
	T data;
	LinkNode<T> *link;
	LinkNode(LinkNode<T> *ptr = NULL){
		link = ptr;
	}
	LinkNode(const T &item, LinkNode<T> *ptr = NULL){
		data = item;
		link = ptr;
	}
};

template <typename T>
class LinkedQueue{//无头结点
public:
	LinkedQueue(){
		rear = NULL;
		front = NULL;
	}
	~LinkedQueue(){
		makeEmpty();
	}
	bool EnQueue(const T &x);
	bool DeQueue(T &x);
	bool getFront(T &x)const;
	void makeEmpty();
	bool IsEmpty()const{
		return front == NULL;
	}
	int getSize()const;
	friend ostream& operator << (ostream &os, LinkedQueue<T> &Q){
		LinkNode<T> *p = Q.front;
		int i = 0;
		while (p){
			os << "#" << ++i << ": " << p->data << endl;
			p = p->link;
		}
		os << "Queue Size: " << Q.getSize() << endl;
		return os;
	}
	void output();
protected:
	LinkNode<T> *front, *rear;
};

template <typename T>
void LinkedQueue<T>::makeEmpty(){
	LinkNode<T> *p;
	while (front){
		p = front;
		front = front->link;
		delete p;
	}
}

template <typename T>
bool LinkedQueue<T>::EnQueue(const T &x){
	if (!front){
		front = rear = new LinkNode<T>(x);
		if (!front)	return false;
	}
	else{
		rear->link = new LinkNode<T>(x);
		if (!(rear->link))	return false;
		rear = rear->link;
	}
	return true;
}

template <typename T>
bool LinkedQueue<T>::DeQueue(T &x){
	if (IsEmpty())	return false;
	LinkNode<T> *p = front;
	x = front->data;
	front = front->link;
	delete p;
	return true;
}

template <typename T>
bool LinkedQueue<T>::getFront(T &x)const{
	if (IsEmpty())	return false;
	x = front->data;
	return true;
}

template <typename T>
int LinkedQueue<T>::getSize()const{
	LinkNode<T> *p = front;
	int k = 0;
	while (p){
		p = p->link;
		k++;
	}
	return k;
}

template <typename T>
void LinkedQueue<T>::output(){
	LinkNode<T> *p = front; int i = 1;
	while (i <= getSize())	{
		cout << p->data << "  "<<endl;
		p = p->link;
        i++;
	}
}
#endif

双端队列