C++ 队列

普通队列

#include <iostream>
using namespace std;

#define SUM 3 // 队列容量

// 节点的定义
template<class T>
struct QNode
{
public:

    QNode() { } // 默认构造
    
    // 有参构造
    QNode(T t, QNode* pNext)
    {
        this->data = t;
        this->pNext = pNext;
    }
public:
    T data; // 数据域
    QNode* pNext; // 指针域
};

// 队列
template<class T>
class Queue
{
public:
    Queue(); // 默认构造
    ~Queue(); // 析构函数
    
    void push(T t); // 入队
    T pop(); // 出队
    T front(); // 获取队头元素
    T back(); // 获取队尾元素
    bool empty(); // 判读队列是否为空
    bool full(); // 判断队列是否已满
private:
    QNode<T>* m_front; // 队头
    QNode<T>* m_rear; // 队尾
    int m_sum; // 队列中节点数目
};

// 初始化队列
template<class T>
Queue<T>::Queue()
{
    m_front = m_rear = new QNode<T>();
    m_front->pNext = NULL;
    m_sum = 0;
}

// 清空队列
template<class T>
Queue<T>::~Queue()
{
    QNode<T>* p,q;
    m_rear = m_front;
    p = m_front->pNext;
    m_front->pNext = NULL;
    while (p)
    {
        q = p;
        p = p->pNext;
        delete q;
    }
    delete m_front;
    m_front = m_rear = NULL;
}

// 进队
template<class T>
void Queue<T>::push(T t)
{
    if (!full())
    {
        QNode<T>* p = new QNode<T>(t, NULL);
        m_rear->pNext = p;
        m_rear = p;
        m_sum++;
    }
    else
    {
        cout << "队列已满" << endl;    
    } 
}

// 出队
template<class T>
T Queue<T>::pop()
{
    QNode<T>* tmp; // 指向被删除节点，方便释放空间 & 判断被删节点是否是对尾节点
    if (empty())
    {
        cerr<<"Error, queue is empty!";
    }
    tmp = m_front->pNext;
    m_front->pNext = tmp->pNext;
    if (m_rear == tmp)
    {
        m_rear = m_front;    
    }
    m_sum--;
    return tmp->data;
}

// 获取队头元素
template<class T>
T Queue<T>::front()
{
    if (empty())
    {
        cerr<<"Error, queue is empty!";
    }
    return m_front->pNext->data;
}

// 获取队尾元素
template<class T>
T Queue<T>::back()
{
    if (empty())
    {
        cerr<<"Error, queue is empty!";
    }
    return m_rear->data;
}

// 队列是否为空
template<class T>
bool Queue<T>::empty()
{
    return m_front == m_rear;    
}

// 队列是否已满
template<class T>
bool Queue<T>::full()
{
    return m_sum < SUM ? false : true;
}

// 测试内置数据类型
void int_test()
{
    Queue<int>* que = new Queue<int>();
    
    // 出队
    //que->pop();
    
    // 入队
    que->push(10);
    que->push(20);
    que->push(30);
    
    // 获取队头元素
    cout << "当前队头元素为：" << que->front() << endl;
    
    // 出队
    while (!que->empty())
    {
        int tmp = que->pop();
        cout << "出队元素：" << tmp << endl;
    }
}

int main()
{
    
    int_test();

    return 0;    
}

循环队列

#include <iostream>
using namespace std;
const int MAX = 3;

template<class T>
class CirQueue
{
public:
    CirQueue(); // 默认构造
    ~CirQueue(); // 析构函数
    void EnQueue(T t); //元素t入队
    T DeQueue(); // 队头元素出队
    T GetQueue(); // 获取队头元素，不删除队头
    bool Empty(); // 判断队列是否为空
private:
    T* data; // 存放队列的数组
    int front, rear; // 头指针和尾指针
};

// 构造函数  置空队列
template<class T>
CirQueue<T>::CirQueue()
{
    data = new T[MAX];
    front = rear = 0;    
}

// 析构函数  清空队列
template<class T>
CirQueue<T>::~CirQueue()
{
    if (data)
    {
        delete [] data; 
        data = NULL;
    }   
}

//元素t入队
template<class T>
void CirQueue<T>::EnQueue(T t)
{
    if ((rear + 1) % MAX == front) // 判断队列是否已满
    {
        cout << "The queue is full!" << endl;    
    }
    else
    {
        data[rear] = t; // 元素t入队
        rear = (rear + 1) % MAX; // 移动尾指针指向下一个空间
    }
}

// 队头元素出队
template<class T>
T CirQueue<T>::DeQueue()
{
    if (Empty())
    {
        cerr << "Error, queue is empyt!" << endl;
    }
    else
    {
        T tmp = data[front];
        front = (front + 1) % MAX;
        return tmp;
    }
}

// 获取队头元素，不删除队头
template<class T>
T CirQueue<T>::GetQueue()
{
    if (Empty())
    {
        cerr << "Error, queue is empyt!" << endl;
    }
    else
    {
        return data[front];    
    }
}

// 判断队列是否为空
template<class T>
bool CirQueue<T>::Empty()
{
    return front == rear;    
}

// 测试内置数据类型
void int_test()
{
    CirQueue<int>* que = new CirQueue<int>();
    
    que->EnQueue(10);
    que->EnQueue(20);
    
    int tmp = que->DeQueue();
    
    cout << "出队的队头元素" << tmp << endl;
    
    tmp = que->DeQueue();
    cout << "出队的队头元素" << tmp << endl;
    
    que->EnQueue(30);
    que->EnQueue(40);
    
    for (int i = 0; que->Empty() != true; ++i)
    {
        tmp = que->DeQueue();
        cout << "出队的队头元素" << tmp << endl;
    }
}

class Person
{
public:
    Person() { }
    Person(string name, int age)
    {
        this->name = name;
        this->age = age;
    }
public:
    string name;
    int age;
};

// 测试自定义数据类型
void person_test()
{
    CirQueue<Person>* que = new CirQueue<Person>();
    
    Person p1("张三", 12);
    Person p2("李四", 14);
    
    que->EnQueue(p1);
    que->EnQueue(p2);
    
    Person tmp = que->DeQueue();
    
    cout << "出队的队头元素 姓名：" << tmp.name << " 年龄：" << tmp.age << endl;
    
    tmp = que->DeQueue();
    cout << "出队的队头元素 姓名：" << tmp.name << " 年龄：" << tmp.age << endl;
    
    Person p3("王五", 15);
    Person p4("七七", 17);
    
    que->EnQueue(p3);
    que->EnQueue(p4);
    
    for (int i = 0; que->Empty() != true; ++i)
    {
        tmp = que->DeQueue();
        cout << "出队的队头元素 姓名：" << tmp.name << " 年龄：" << tmp.age << endl;
    }
    
    tmp = que->GetQueue();
    
    cout << "获取队头元素 姓名：" << tmp.name << " 年龄：" << tmp.age << endl;
}

int main()
{
    
    //int_test();
    
    person_test();
    
    return 0;    
}