反转链表 栈 三指针_指针栈翻转

传送门

分析：

本题主要考察程序的鲁棒性，主要注意一些特殊测试，例如：当输入的链表头指针为nullptr或者整个链表只有一个节点时，或者反转后的链表可能出现断裂

思路主要有两种：1.借助一个栈来实现，比较直观

2.三指针的做法，我们每次只进行相邻两个节点的反转，同时记录下一个节点指针，这是因为如果不记录下一个节点指针，我们将无法访问原链表，这样迭代进行。

三指针的做法，由于是原地进行，所以空间复杂度为O(1)，同时由于只遍历一次原链表，时间复杂度也较栈的做法低。

栈：

//翻转链表，也可以使用栈来实现
/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    Solution()
    {
        
    }
    ~Solution()
    {
        
    }
    ListNode* ReverseList(ListNode* pHead) {
        if(pHead==nullptr) return nullptr;
        stack<int>solve;
        while(!solve.empty()) solve.pop();
        ListNode* pNode = pHead;
        while(pNode!=nullptr)
        {
            solve.push(pNode->val);
            pNode = pNode->next;
        }
        ListNode* pNew = new ListNode(solve.top());
        solve.pop();
        ListNode* pre = pNew;
        while(!solve.empty())
        {
            int v = solve.top();
            solve.pop();
            ListNode* now = new ListNode(v);
            pre->next = now;
            pre = now;
        }
        return pNew;
    }
};

三指针

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    Solution()
    {
         
    }
    ~Solution()
    {
         
    }
    ListNode* ReverseList(ListNode* pHead) {
        if(pHead==nullptr) return nullptr;
        ListNode* pPre = nullptr;
        ListNode* pNode = pHead;
        ListNode* pReversedNode = nullptr;
        while(pNode!=nullptr)
        {
            ListNode* pNext = pNode->next;
            if(pNext==nullptr)
            {
                pReversedNode = pNode;
            }
            pNode->next = pPre;
            pPre = pNode;
            pNode = pNext;
        }
        return pReversedNode;
    }
};