数据结构（五）、C++链表实现队列

链表实现队列

1、实现原理

通过操作数组的下标来实现队列结构。
栈数组结构体定义：

    template<class T>
    class Queue
    {
    public:
        struct node
        {
            node() :m_data(), m_next(nullptr) {}
            T m_data;
            node* m_next;
        };
        Queue() :m_front(nullptr), m_fear(nullptr) {}
    private:
        node* m_front;   // 头节点
        node* m_fear;    // 尾节点
    }

（1）、入队实操说明

• 插入元素（1）

        /*
             队列链表m_stNode:
             m_front = m_fear = nullptr     temp节点    -----  m_next           
                                                        | 1 |----------> nullptr
                                                        -----    

                                       ||
                                       ||   m_front = m_fear = temp
                                       ||
                                      \\//

                                -----  m_next              
                                | 1 |----------> nullptr   
                                -----                      
                                |   |
                           m_front  m_fear        
        */

• 插入元素（2）

        /*
             队列链表m_stNode:
                      -----  m_next                  
                      | 1 |----------> nullptr         temp节点    -----  m_next
                      -----                                        | 2 |----------> nullptr
                      |   |                                        -----
                 m_front  m_fear    

                                       ||
                                       ||   m_fear->m_next = temp;
                                       ||   m_fear = temp;        
                                      \\//

                     -----  m_next    -----  m_next
                     | 2 |----------> | 1 |----------> nullptr
                     -----            -----
                      |                |   
                    m_fear          m_front  
        */

• 插入元素（3）

        /*
             队列链表m_stNode:
                 -----  m_next    -----  m_next
                 | 2 |----------> | 1 |----------> nullptr       temp节点    -----  m_next
                 -----            -----                                      | 3 |----------> nullptr
                  |                |                                         -----
                m_fear          m_front

                                       ||
                                       ||   m_fear->m_next = temp;
                                       ||   m_fear = temp;
                                      \\//

                   -----  m_next     -----  m_next    -----  m_next
                   | 3 |---------->  | 2 |----------> | 1 |----------> nullptr
                   -----             -----            -----
                      |                                 |
                    m_fear                           m_front
        */

（2）、出队实操说明

• 移除首元素（1）

        /*
             队列链表m_stNode:
                   -----  m_next     -----  m_next    -----  m_next
                   | 3 |---------->  | 2 |----------> | 1 |----------> nullptr
                   -----             -----            -----
                      |                                 |
                    m_fear                           m_front

                                       ||
                                       ||   m_front = m_front->m_next
                                       ||   
                                      \\//

                   -----  m_next     -----  m_next    
                   | 3 |---------->  | 2 |----------> nullptr
                   -----             -----            
                      |                |
                    m_fear          m_front
        */

• 移除首元素（2）

        /*
             队列链表m_stNode:
                   -----  m_next     -----  m_next
                   | 3 |---------->  | 2 |----------> nullptr
                   -----             -----
                      |                |
                    m_fear          m_front

                                       ||
                                       ||   m_front = m_front->m_next
                                       ||
                                      \\//

                   -----  m_next   
                   | 3 |----------> nullptr
                   -----           
                   |  |
               m_fear m_front
        */

• 移除首元素（3）

        /*
             队列链表m_stNode:
                   -----  m_next
                   | 3 |----------> nullptr
                   -----
                   |  |
               m_fear m_front

                                       ||   m_fear = m_fear->m_next;
                                       ||   m_front = m_front->m_next
                                       ||
                                      \\//
             
                                    nullptr                               
        */

2、整体代码

#include <iostream>

namespace queue_list
{
        template<class T>
    class Queue
    {
    public:
        struct node
        {
            node() :m_data(), m_next(nullptr) {}
            T m_data;
            node* m_next;
        };
        Queue() :m_front(nullptr), m_fear(nullptr) {}

        /**
         * @brief 尾插
         */
        void push(T m_pdata)
        {
            node* temp = new node;
            temp->m_data = m_pdata;
            temp->m_next = nullptr;

            if (m_front == nullptr)         // 插入第一个元素时，让头尾节点都指向temp这块内存
            {
                m_front = temp;
                m_fear = temp;
            }
            else
            {
                m_fear->m_next = temp;    // 将temp节点赋值到尾指针的下一个指针，因为头尾节点都指向同一块内存，所以头节点保存全部队列节点
                m_fear = temp;            // 将temp赋值给m_fear尾节点，方便下一次插入操作
            }
        }

        /**
         * @brief 头删
         */
        void pop()
        {
            if (m_front == nullptr)       // 头节点为空，表示队列为空
            {
                std::cout << "queue is empty" << std::endl;
            }
            else
            {
                node* temp = m_front;             // 先保存头节点
                if (m_front == m_fear)            // 当队列只剩下一个元素时，操作尾节点的下一个指针为空
                {
                    m_fear = m_fear->m_next;
                }
                m_front = m_front->m_next;        // 头节点指向头节点原来的下一个指针
                delete temp;
            }
        }

        /**
         * @brief 打印
         */
        void print_queue()
        {
            node* temp = m_front;
            while (temp != nullptr)
            {
                std::cout << temp->m_data << " ";
                temp = temp->m_next;
            }
            std::cout << std::endl;
        }

    private:
        node* m_front;   // 头节点
        node* m_fear;    // 尾节点
    };

    void test_queue_list()
    {
        queue_list::Queue<int> m_queue;
        m_queue.push(1);
        m_queue.push(2);
        m_queue.push(3);
        m_queue.print_queue();       // 1 2 3

        m_queue.pop();
        m_queue.print_queue();       // 2 3

        m_queue.pop();
        m_queue.print_queue();       // 3

        m_queue.pop();
        m_queue.print_queue();
    }

}// namespace queue_list

int main()
{
    queue_list::test_queue_list();
    return 0;
}