数据结构（三）、C++链表实现栈

（三）、C++链表实现栈

1、链表实现栈原理

单链表的基础上实现栈，入栈实现：单链表头插，出栈实现：单链表头删，栈顶实现：返回头节点值

2、入栈

（1）、入栈实操流程

• 插入（1）

        /*
             栈链表m_stNode:
                             -----  m_next
                             | 1 |---------->nullptr
                             -----
        */

• 插入（2）

        /*
             栈链表m_stNode: 
                             -----  m_next                  -----  m_next    -----  m_next
                             | 1 |---------->nullptr        | 2 |----------> | 1 |---------->nullptr
                             -----                          -----            -----
        */

• 插入（3）

        /*
             栈链表m_stNode:
                             -----  m_next    -----  m_next              -----  m_next    -----  m_next    -----  m_next
                             | 2 |----------> | 1 |----------> nullptr   | 3 |----------> | 2 |----------> | 1 |---------->nullptr
                             -----            -----                      -----            -----            -----
        */

(2)、C++代码实现

        /**
         * @brief 插入
         */
        void push(T p_nX)
        {
            node* temp = new node;          // 申请一个新节点temp
            temp->m_nVal = p_nX;            // 新节点temp赋值
            temp->m_next = m_stNode;        // 将新节点temp的next指针指向栈链表m_stNode头节点
            m_stNode = temp;                // 将新节点temp赋值给栈链表m_stNode头节点
        }

3、出栈

（1）、出栈实操流程

• 移除元素（3）

       /*
             栈链表m_stNode:
                             -----  m_next    -----  m_next    -----  m_next               -----  m_next    -----  m_next              
                             | 3 |----------> | 2 |----------> | 1 |---------->nullptr     | 2 |----------> | 1 |----------> nullptr          
                             -----            -----            -----                       -----            -----                      
        */

• 移除元素（2）

        /*
             栈链表m_stNode:
                             -----  m_next    -----  m_next             -----  m_next                  
                             | 2 |----------> | 1 |---------->nullptr   | 1 |----------> nullptr              
                             -----            -----                     -----                          
        */

• 移除元素（1）

        /*
             栈链表m_stNode:
                             -----  m_next
                             | 1 |---------->nullptr          nullptr
                             -----
        */

(2)、C++代码实现

        /**
         * @brief 删除
         */
        void pop()
        {
            if (m_stNode == nullptr)
            {
                cout << "栈为空" << endl;
            }
            else
            {
                node* temp = m_stNode;          // 先保存栈链表m_stNode头节点
                m_stNode = m_stNode->m_next;    // 移除栈顶元素：将栈链表m_stNode头节点的下一个指针赋值给栈链表m_stNode头节点
                delete temp;                    // 删除节点，内存清除
            }
        }

4、获取栈顶元素

• C++代码实现

        /**
         * @brief 获取栈顶元素
         */
        T top()
        {
            if (m_stNode == nullptr)
            {
                cout << "栈为空" << endl;
                return 0;
            }
            return m_stNode->m_nVal;
        }

5、整体代码

#include <iostream>
using namespace std;
/**
 * @namespace 链表实现栈
 */
namespace stack_list
{
    template<class T>
    struct Stack
    {
        Stack() :m_stNode(nullptr) {}
        struct node 
        {
            node() :m_nVal(), m_next(nullptr) {}
            T m_nVal;                       // 值
            node* m_next;                   // 下一个指针
        };
        node* m_stNode;                     // 栈链表m_stNode头节点

        /**
         * @brief 插入
         */
        void push(T p_nX)
        {
            node* temp = new node;          // 申请一个新节点temp
            temp->m_nVal = p_nX;            // 新节点temp赋值
            temp->m_next = m_stNode;        // 将新节点temp的next指针指向栈链表m_stNode头节点
            m_stNode = temp;                // 将新节点temp赋值给栈链表m_stNode头节点
        }

        /**
         * @brief 删除
         */
        void pop()
        {
            if (m_stNode == nullptr)
            {
                cout << "栈为空" << endl;
            }
            else
            {
                node* temp = m_stNode;        // 先保存栈链表m_stNode头节点
                m_stNode = m_stNode->m_next;    // 移除栈顶元素：将栈链表m_stNode头节点的下一个指针赋值给栈链表m_stNode头节点
                delete temp;                 // 删除节点
            }
        }

        /**
         * @brief 判空
         */
        bool isEmpty()
        {
            return nullptr == m_stNode;
        }

        /**
         * @brief 大小
         */
        int size()
        {
            node* temp = m_stNode;         // 先保存栈链表m_stNode头节点
            int nSize = 0;
            while (temp != nullptr)
            {
                temp = temp->m_next;       // 栈链表m_stNode头节点指向下一个指针
                nSize++;
            }
            return nSize;
        }

        /**
         * @brief 打印
         */
        void printStack()
        {
            node* temp = m_stNode;         // 先保存栈链表m_stNode头节点
            while (temp != nullptr)
            {
                cout << temp->m_nVal << " ";
                temp = temp->m_next;       // 栈链表m_stNode头节点指向下一个指针       
            }
            cout << endl;
        }

    };

    void test_stack_list()
    {
        stack_list::Stack<int> st;
        st.push(1);
        st.push(2);
        st.push(3);
        cout << "栈大小:" << st.size() << endl;          // 栈大小:3
        st.printStack();                                // 3 2 1

        st.pop();
        cout << "栈大小:" << st.size() << endl;          // 栈大小:2
        st.printStack();                                // 2 1

        st.pop();
        st.pop();
        st.printStack();

        st.pop();
        cout << "栈大小:" << st.size() << endl;          // 栈大小:0
        st.printStack();                                // 
    }
}// namespace stack_list

int main()
{
    stack_list::test_stack_list();
    return 0;
}