数据结构与算法_顺序队列

queue.h

#ifndef _QUEUL_H
#define _QUEUE_H 
#include<iostream>
using namespace std;
template<class T>
class Queue
{
public:
	Queue(int queueCapacity = 10);
	~Queue();
	bool IsEmpty() const;
	T& Front() const;
	T& Rear() const;
	void Push(const T& item);
	void Pop();
private:
	T* queue;
	int front;
	int rear;
	int capacity;
};

template<class T>
Queue<T>::Queue(int queueCapacity) : capacity(queueCapacity)
{
	if (capacity < 1)
		throw "Queue capacity must be > 0";
	queue = new T[capacity];
	//此顺序队列在设计时第0个位置空闲，开始时从第一个下标开始存放数据 
	front = rear = 0;
}

template<class T>
inline bool Queue<T>::IsEmpty() const
{
	return (front == rear);
}
//此顺序队列在设计时第0个位置空闲，开始时从第一个下标开始 
template<class T>
void Queue<T>::Push(const T& item)
{
	
	if ((rear + 1) % capacity == front)	//队列满了 
	{
		//扩大空间 加倍
		T* newQueue = new T[2 * capacity];
		//先判断是否发生了回绕 
		int start = (front + 1) % capacity;
		if (start < 2)	//没有回绕  front一直在第0个元素上 
		{
			//这种情况是在扩充之后front依然指向第一个位置 
			copy(queue+start, queue + capacity, newQueue+1);
			//这种情况是在扩充之后front指向最后一个位置 	
			//copy(queue+start, queue+start+capacity-1, newQueue); 	
		}
		else	//front的位置发生了移动，说明发生了回环 
		{
			copy(queue + start, queue + capacity, newQueue + 1);
			copy(queue, queue + rear + 1, newQueue + capacity - start + 1);
			//copy(queue+start, queue+capacity, newQueue);
			//copy(queue, queue+rear+1, newQueue+capacity-start);
		}
		front = 0;
		//front = 2*capacity - 1;
		rear = capacity - 1;
		//rear = capacity - 2;
		capacity *= 2;
		delete[] queue;
		queue = newQueue;
	}
	//	if(rear == capacity-1)
	//		rear = 0;
	//	else
	//		rear++;
	rear = (rear + 1) % capacity;	//高水平 
	queue[rear] = item;
}

template<class T>
inline T& Queue<T>::Front() const
{
	if (IsEmpty())
		throw "Queue id empty!";
	return queue[(front + 1) % capacity];	//front指向的位置是空的，队首元素是front+1 
}
template<class T>
inline T& Queue<T>::Rear() const
{
	if (IsEmpty())
		throw "Queue id empty!";
	return queue[rear];
}
template<class T>
void Queue<T>::Pop()
{
	if (IsEmpty())
		throw "Queue is empty,cannot delete";
	front = (front + 1) % capacity;	//front始终指向队首元素的前一个空位置 
	queue[front].~T();
}

template<class T>
Queue<T>::~Queue()
{
	delete[] queue;
}
#endif

main.h

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


int main()
{
	Queue<int> q(5);
	q.Push(1);
	q.Push(2);
	q.Push(3);
	q.Push(4);


	cout << q.Front() << endl;
	cout << q.Rear() << endl;
	q.Pop();
	q.Pop();
	q.Pop();
	q.Pop();

	q.Push(5);
	q.Push(6);
	q.Push(7);
	q.Push(8);
	q.Push(9);

	cout << q.Front() << endl;
	cout << q.Rear() << endl;
	//system("pause");
	return 0;
}