力扣刷题笔记：反转链表（新建链表&双指针法&递归）

反转链表要求将输入的链表反向输出，当然新建一个链表后，对长度为n的原链表进行n次遍历将链表从后向前的元素添加到新链表中这样的暴力解法，但是空间复杂度明显很高，暂不考虑。现在只考虑循环一遍的方法的话，可以使用新建链表、双指针和递归这两种方法。
Leetcode:206.反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

我一开始的想法是这样的：建立一个哨兵结点，然后将哨兵结点右侧第一个的结点删除，创建一个与删除结点值一样指向NULL的结点，再继续删除利用类似尾插的方法建立新的链表。

/**
 * 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* cur = new ListNode(0);
        cur->next = head;
        ListNode* rmove = cur;
        ListNode* lmove = nullptr;
        while(rmove->next != nullptr)
        {   
            ListNode* del = rmove->next;
            ListNode* addnode =new ListNode(del->val,lmove);
            rmove->next = del->next;
            delete del;
            lmove = addnode;
        } 
        return lmove;
    }
};

当我以为我这种做法很聪明的时候我看到了这张图：

没错这就是双指针法，上图就是双指针的精髓，利用快慢两个指针交替修改指向，简直清爽的不da鸟，当然我们依然需要一个指针存放我们前面一个指针cur->next的值，来避免修改指针指向后丢失下一个值。

/**
 * 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* fast = head;
            ListNode* slow = nullptr;
            while(fast != NULL)
           {   
            ListNode* mid;
            mid = fast->next;
            fast->next = slow;
            slow = fast;
            fast = mid;
           } 
           return slow;      
    }
};

最后就是利用递归的方法，其实本题利用递归的方法，其实也是利用双指针的思想，类似于将while取代了，内存占用小了，但是一定要注意边界条件，如果边界条件不对，就有可能会爆栈。

/**
 * 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* fun(ListNode* fast,ListNode* slow)
    {
        if(fast == NULL)//设置边界条件，当前面一个指针为空后开始返回
        {return slow;}
        ListNode* tmp = fast->next;
        fast->next = slow;
        return fun(tmp,fast);
    } 
    ListNode* reverseList(ListNode* head) {
        return fun(head,NULL);
    }
};