队列和栈一样,也是相对比较常见的数据结构。队列遵守的是“先进先出”的原则,因此在一些数据先到先处理的场景,可能会用到。下边使用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() {
//
//
//
}