链表--part 4--翻转链表(leetcode 206)

基本思想

建议先理解双指针的方法再去理解递归方法。

双指针法（或者叫三指针的方法）

整个过程举个例子：原本的链表是1->2->3->4->5
我创建一个cur用于指向当前节点 一个pre指向前一个节点，然后需求一个临时存储后续节点的变量temp用于不忘记关系，然后就此循环得到新的链表。

过程就是：

1. NULL<-1->2->3->4->5 此时cur指向1 pre指向null temp指向2 然后使cur的next指向pre。
2. NULL<-1<-2->3->4->5 此时cur指向2 pre指向1 temp指向3 然后使cur的next指向pre。
   等等进行循环。

code：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = NULL;
        ListNode* cur = head;
        ListNode* temp;
        while(cur)
        {
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

递归法

实际上就是基于双指针法的理解进行的优化：

class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);
    }

};

使用虚拟头节点解决反转

还有就是可以使用虚拟头节点进行反转，类似头插法的思路。这里就不演示了，提供一个思路。

使用栈解决链表的反转问题

对于这种反序问题，自然而然就可以想得到使用栈，这也是一个小的想法。

leetcode 206 反转链表

链接
见上