leetcode206反转链表（双指针+递归解法）

本文主要讲解反转链表中的的要点和细节，先讲解双指针，然后讲解递归

• 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

具体c++和java代码如下，末尾

具体要点：

1.反转链表的核心操作：将当前节点指向之前的节点

                                                           即  cur->next=pre

---

2.根据上面想法，会涉及到当前节点和上一个节点，所以需要定义两个临时指针，不断移动，进行反转操作。

        那么出现新问题：两个节点应该怎么初始化

        解决方法：考虑一下头节点的开始情况

        即：cur设为头节点head，pre设为null（因为第一次反转要让头节点指向null，构成新链表的尾部）

                                                        ListNode* cur=head;

                                                        ListNode* pre=nullptr;

---

3.定义好两个指针，就可以开始遍历了，

        此时出现新的问题：遍历终止条件是什么？到底是cur==尾节点终止，还是cur==null终止呢

        解决方法：考虑一下尾部节点的情况

        即：当cur==最后一个节点（pre==倒数第二个节点），仍然需要反转。

               只有当cur==null，pre==最后一个节点时，猜终止遍历

                                                        while (cur != nullptr){ }

---

4.遍历开始，开始执行反转操作，但是反转操作完，当我们要移动到下一个位置时，发现cur->next已经被我们指向了pre。原本的下一个位置丢了

        解决方法：定义一个temp，在反转前保存cur->next，反转后赋给cur，实现移动

        细节：移动时注意顺序，先移动pre！不然原本的cur就先被覆盖了

                                             ListNode* temp = cur->next;    //保存下一个节点，便于后续移动

                                             cur->next = pre;    //反转

                                             pre = cur;     //移动，注意顺序

                                             cur = temp;

---

5.遍历结束，反转都完成了，应该返回什么呢？

        此时pre指向最后一个节点（反转后的头节点），cur指向null

        所以应该返回pre，即新链表的头节点

                                              return pre；

---

6.递归的操作我在下面代码中详细解释

---

        感觉写的还凑活希望给个赞呢

c++代码如下

//双指针
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        //核心操作：cur指向pre
        //反转后，cur和pre移动到下一个位置

        //初始化
        ListNode* cur=head;
        ListNode* pre=nullptr;
        while (cur != nullptr) {
            //保存下一个节点，便于后续移动 
            ListNode* temp = cur->next;

            //反转
            cur->next = pre;

            //移动，注意顺序
            pre = cur;
            cur = temp; 
        }
        //遍历完成后，pre指向了新的头节点（原来的尾节点），cur指向了null
        return pre;
    }
};

//递归
class Solution {
public:
    //定义递归函数
    ListNode* reverse(ListNode* cur ,ListNode* pre) {
        //递归终止条件
        if (cur == nullptr)return pre;

        //用temp保存cur->next
        ListNode* temp = cur->next;

        //具体操作：反转
        cur->next = pre;

        //调用递归，传参时考虑了移动
        return reverse(temp, cur);
    }

    ListNode* reverseList(ListNode* head) {
        //这里考虑了初始化
        return reverse(head, nullptr);
    }
};

java代码

class Solution {
    //双指针
    public ListNode reverseList(ListNode head) {
        ListNode cur=head;
        ListNode pre=null;
        while(cur!=null){
            ListNode temp=cur.next;
            cur.next=pre;
            pre=cur;
            cur=temp;
        }
        return pre;
    }
}

class Solution {
    //递归
    public ListNode reverseList(ListNode head) {
        //传参考虑初始化
        return reverse(head,null);
    }
    //递归函数
    public ListNode reverse(ListNode cur,ListNode pre){
        //递归终止条件，出口
        if(cur==null) return pre;
        //保存
        ListNode temp=cur.next;
        //反转
        cur.next=pre;
        //递归操作，考虑移动
        return reverse(temp,cur);
    }
}