<8> 其实，队列也可以这么来替代。

两个栈来代替一个队列，一个栈正常存储数据，另一个栈在执行top()时候存储“从第一个栈中去取出来的数据”，并将第二个栈的顶端数据弹出即可。

#include <iostream>
#include <malloc.h>
#include <algorithm>
#include <functional>



//------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------
// 基类

class UnCopyable{
public:
	UnCopyable();
	~UnCopyable();

private:
	UnCopyable(const UnCopyable& e);
	UnCopyable& operator=(const UnCopyable& e);
};

UnCopyable::UnCopyable(){

}

UnCopyable::~UnCopyable(){

}

UnCopyable::UnCopyable(const UnCopyable& e) {
	*this = e;
}
UnCopyable& UnCopyable::operator=(const UnCopyable&) {
	return *this;
}


// ------------------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------------------
// 基类UnCopyable是为了阻止MyQueue可以被赋值和拷贝

class MyQueue : private UnCopyable {

public:
	MyQueue( unsigned int size ) 
		: m_Top( -1 ), m_Top_2(-1), 
		  m_MAX( -100000 ), m_Min( 100000 )
	{
		m_VAPACITY = size;
		m_Data = (int*)malloc(sizeof(int)*m_VAPACITY);
		m_Data_2 = (int*)malloc(sizeof(int)*m_VAPACITY);
	}
	~MyQueue();
private:
	int *m_Data;													//	存取值的数组
	int *m_Data_2;													//	存取值的数组
	int  m_Top;														//  栈顶索引
	int  m_Top_2;													//  栈顶索引
	int  m_MAX;														//  数组中的最大值
	int  m_Min;														//  数组中的最小值
	unsigned int m_VAPACITY;										//  栈的容量
public:
	enum QueueSort
	{
		less,
		greater
	};

	unsigned int QueueVapacity() const;								//  栈的容量
	unsigned int QueueMax() const;									//  栈最大
	unsigned int QueueMin() const;									//  栈最小
public:
	bool isEmpty();													//  判断栈是否为空
	bool isFull();													//  判断栈是否满了
	bool isEmpty_2();												//  判断栈是否为空
	bool isFull_2();												//  判断栈是否满了
	void pop();														//  出栈（删除栈顶元素）
	void push( int value );											//  入栈
	void pop_2();													//  出栈（删除栈顶元素）
	void push_2(int value);											//  入栈
	unsigned int Top();												//  取值
	unsigned int Top_2();
	unsigned int Tops();
	int max();														//  栈中最大值（版本1）
	int min();														//  栈中最小值（版本1）
	int max1();														//  栈中最大值（版本2）
	int min1();														//  栈中最小值（版本2）
	void QueueOrder( QueueSort Strategy );							//  将栈中的元素排序
};


unsigned int MyQueue::QueueVapacity() const {
	return m_VAPACITY;
}

unsigned int MyQueue::QueueMax() const {
	return m_MAX;
}

unsigned int MyQueue::QueueMin() const {
	return m_Min;
}

bool MyQueue::isEmpty(){
	return m_Top == -1;
}

bool MyQueue::isEmpty_2() {
	return m_Top_2 == -1;
}

bool MyQueue::isFull() {
	return m_Top == m_VAPACITY - 1;
}

bool MyQueue::isFull_2() {
	return m_Top_2 == m_VAPACITY - 1;
}

void MyQueue::pop() {
	try{
		 if (!isEmpty()) {
			 m_Top--;
		 }
		 else{
			 std::cout << "the Queue is empty." << std::endl;
		 }
	}
	catch (const std::exception& e){
		std::cout << e.what() << std::endl;
	}	
}

void MyQueue::push( int value ) {
	try{
		if (!isFull()) {
			m_Data[m_Top++] = value;
		}
		else{
			std::cout << "the Queue is full." << std::endl;
		}
	}
	catch (const std::exception& e){
		std::cout << e.what() << std::endl;
	}
}

void MyQueue::pop_2() {
	try {
		if (!isEmpty_2()) {
			m_Top_2--;
		}
		else {
			std::cout << "the Queue is empty." << std::endl;
		}
	}
	catch (const std::exception& e) {
		std::cout << e.what() << std::endl;
	}
}

void MyQueue::push_2(int value) {
	try {
		if (!isFull_2()) {
			m_Data_2[m_Top_2++] = value;
		}
		else {
			std::cout << "the Queue is full." << std::endl;
		}
	}
	catch (const std::exception& e) {
		std::cout << e.what() << std::endl;
	}
}

unsigned int MyQueue::Top() {
	if (!isEmpty()) {
		int Temp = m_Data[m_Top];
		m_Top--;
		return Temp;
	}
}

unsigned int MyQueue::Top_2() {
	if (!isEmpty()) {
		int Temp = m_Data_2[m_Top_2];
		m_Top_2--;
		return Temp;
	}
}

unsigned int MyQueue::Tops() {
	if (!isEmpty_2()) {
		
		// 第一步（判断m_data_2不是空，直接将m_data_2的顶端数据倒出）
		return Top_2();
	}
	else{

		// 第二步（判断m_data_2是空，直接将m_data_1的顶端数据全部数据倒出到m_data_2里，然后将m_data_2的顶端数据倒出）
		while ( !isEmpty() ){
			push_2(Top());
		}

		return Top_2();
	}
}

int MyQueue::max(){
	if (!isEmpty()) {
		std::sort(m_Data, m_Data + m_Top + 1, std::greater<int>());
		return m_Data[0];
	}
}

int MyQueue::min() {
	if (!isEmpty()) {
		std::sort(m_Data, m_Data + m_Top + 1, std::less<int>());
		return m_Data[0];
	}
}

int MyQueue::max1() {
	if (!isEmpty()) {
		m_MAX = m_Data[0];
		for ( size_t i = 0; i <= m_Top; i++ ){
			if (m_Data[i] > m_MAX) {
				m_MAX = m_Data[i];
			}
		}

		return m_MAX;
	}

	return 0x1000000;
}

void MyQueue::QueueOrder( QueueSort Strategy ) {
	switch (Strategy){
			case QueueSort::greater:	
				std::sort(m_Data, m_Data + m_Top + 1, std::greater<int>());
			case QueueSort::less:
				std::sort(m_Data, m_Data + m_Top + 1, std::less<int>());
			default:
				break;
	}
}

int MyQueue::min1() {
	if (!isEmpty()) {
		m_Min = m_Data[0];
		for ( size_t i = 0; i <= m_Top; i++ ) {
			if (m_Data[i] < m_Min) {
				m_MAX = m_Data[i];
			}
		}
	}

	return 0x1000000;
}

MyQueue::~MyQueue(){

}

int main() {

	MyQueue Q(3);
	Q.push(1);
	Q.push(2);
	Q.push(3);

	std::cout << Q.Tops() << std::endl;
	std::cin.get();
}