隊列的各種操作

隊列和棧一樣，也是相對比較常見的數據結構。隊列遵守的是“先進先出”的原則，因此在一些數據先到先處理的場景，可能會用到。下邊使用C/C++編寫了隊列的自定義實現，其中包括創建、出隊列，入隊列、取值等。

#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_front(0),
		m_rear(0),
		m_MAX(-100000),
		m_Min(100000)
	{
		m_VAPACITY = size;
		m_Data = (int*)malloc(sizeof(int)*m_VAPACITY);
	}

	~MyQueue();
private:
	int *m_Data;													//	存取值的數組
	int  m_front;													//  隊列頭
	int  m_rear;													//  隊列尾
	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();													//  判斷隊列是否滿了
	void deQueue();													//  出隊列（刪除隊列元素）
	void enQueue(int value);										//  入隊列
	const int Top();												//  取值
	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_rear == m_front;
}

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

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

void MyQueue::enQueue(int value) {
	try {
		if (!isFull()) {
			m_Data[m_rear] = value;
			m_rear++;
		}
		else {
			// realloc函數進行擴容 
			std::cout << "the Queue is full.Do you need to expand?" << std::endl;
			m_Data = (int*)realloc(m_Data, sizeof(int)*m_VAPACITY);
		}
	}
	catch (const std::exception& e) {
		std::cout << e.what() << std::endl;
	}
}

const int MyQueue::Top() {
	try {
		if (!isEmpty()) {
			int Temp = m_Data[m_front];
			m_front++;
			return Temp;
		}
		else {
			std::cout << "the Queue is empty." << std::endl;
		}
	}
	catch (const std::exception& e) {
		std::cout << e.what() << std::endl;
	}

	return 0x1000000;
}

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

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

int MyQueue::max1() {
	if (!isEmpty()) {
		m_MAX = m_Data[0];
		for (size_t i = m_front; i <= m_rear; 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_rear - m_front + 1), std::greater<int>());
	case QueueSort::less:
		std::sort(m_Data, m_Data + (m_rear - m_front + 1), std::less<int>());
	default:
		break;
	}
}

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

	return 0x1000000;
}

MyQueue::~MyQueue() {

}

int main() {

	// 
	//
	//
}