1-4 队列：链表实现

队列是一种遵循先进先出（FIFO）原则的线性数据结构。最先插入的元素将最先被移除。

---

链表实现队列的原理

队列可以使用链表实现，其中队列的每个元素都表示为一个节点。

使用链表声明队列

要使用链表实现队列，我们需要维护：

节点结构/类，包含：

• m_data → 存储元素数据
• m_next → 指向下一个节点的指针/引用

两个指针/引用：

• m_front → 指向第一个节点（队头）
• m_rear → 指向最后一个节点（队尾）

class Node 
{
public:
    int m_data;
    Node* m_next;
    Node(int newData) 
    {
        m_data = newData;
        m_next = nullptr;
    }
};

// 队列类
class MyQueue 
{
private:
    Node* m_front;
    Node* m_rear;

public:
    MyQueue() 
    {
        m_front = m_rear = nullptr;
    }
};

---

链表队列的操作

入队操作（Enqueue）

入队操作将元素添加到队列尾部。与数组实现不同，链表没有固定容量，只有在内存耗尽时才会发生溢出。
步骤：

• 创建一个包含给定值的新节点
• 如果队列为空（m_front == nullptr 且 m_rear == nullptr），将 m_front 和 m_rear 都设置为这个新节点
• 否则，将当前 m_rear 的 m_next 指针指向新节点
• 更新 m_rear 指针指向新节点

void enqueue(int newData) 
{
    Node* node = new Node(newData);
    if (isEmpty()) 
    {
        m_front = m_rear = node;
    } 
    else 
    {
        m_rear->m_next = node;
        m_rear = node;
    }
}

时间复杂度： O(1)
辅助空间： O(1)

出队操作（Dequeue）

出队操作从队列头部移除一个元素。
步骤：

• 如果队列为空（m_front == nullptr），返回下溢错误（队列为空）
• 否则，将当前 m_front 节点存储到临时指针中
• 将 m_front 指针移动到下一个节点（m_front = m_front->m_next）
• 如果 m_front 变为 nullptr，同时将 m_rear 设为 nullptr（队列变为空）

// 出队
int dequeue() 
{
    if (isEmpty()) 
    {
        std::cout << "Queue Underflow" << std::endl;
        return -1;
    }
    
    Node* temp = m_front;
    int removedData = temp->m_data;
    m_front = m_front->m_next;
    
    if (m_front == nullptr) m_rear = nullptr;
    delete temp;
    return removedData;
}

时间复杂度： O(1)
辅助空间： O(1)

判空操作（isEmpty）

判空操作检查队列是否没有元素。

• 如果 m_front 指针为 NULL，表示队列为空 → 返回 true
• 否则，队列包含元素 → 返回 false

// 检查是否为空
bool isEmpty() 
{
    return m_front == nullptr;
}

时间复杂度： O(1)
辅助空间： O(1)

获取队首元素（Front）

getFront() 函数返回队列前端的元素，但不移除它。

• 如果队列为空（m_front == NULL），打印消息并返回 -1
• 否则，返回 m_front->m_data（队首的值）

int getFront() 
{
    if (isEmpty()) 
    {
        std::cout << "Queue is empty" << std::endl;
        return -1;
    }
    return m_front->m_data;
}

时间复杂度： O(1)
辅助空间： O(1)

---

完整实现代码

#include <iostream>

// 节点类
class Node 
{
public:
    int m_data;
    Node* m_next;
    Node(int newData) 
    {
        m_data = newData;
        m_next = nullptr;
    }
};

// 队列类
class MyQueue 
{
private:
    int m_currSize;
    Node* m_front;
    Node* m_rear;

public:
    MyQueue() 
    {
        m_currSize = 0;
        m_front = m_rear = nullptr;
    }

    // 检查是否为空
    bool isEmpty() 
    {
        return m_front == nullptr;
    }

    // 入队
    void enqueue(int newData) 
    {
        Node* node = new Node(newData);
        if (isEmpty()) 
        {
            m_front = m_rear = node;
        } 
        else 
        {
            m_rear->m_next = node;
            m_rear = node;
        }
        
        m_currSize++;
    }

    // 出队
    int dequeue() 
    {
        if (isEmpty()) 
        {
            std::cout << "Queue Underflow" << std::endl;
            return -1;
        }
        
        Node* temp = m_front;
        int removedData = temp->m_data;
        m_front = m_front->m_next;
        
        if (m_front == nullptr) m_rear = nullptr;
        delete temp;
        
        m_currSize--;
        return removedData;
    }

    // 获取队首元素
    int getFront() 
    {
        if (isEmpty()) 
        {
            std::cout << "Queue is empty" << std::endl;
            return -1;
        }
        return m_front->m_data;
    }

    // 获取队列大小
    int getSize() 
    {
        return m_currSize;
    }
};

int main() 
{
    MyQueue q;
    
    q.enqueue(10);
    q.enqueue(20);

    std::cout << "Dequeue: " << q.dequeue() << "\n";
    
    q.enqueue(30);

    std::cout << "Front: " << q.getFront() << std::endl;
    std::cout << "Size: " << q.getSize() << std::endl;

    return 0;
}

输出结果：

Dequeue: 10
Front: 20
Size: 2