力扣206(java&python)-反转链表（简单）

题目：

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

示例1：

输入：head = [1,2,3,4,5]

输出：[5,4,3,2,1]

示例2：

输入：head = [1,2]
输出：[2,1]
示例 3：

输入：head = []
输出：[]
 

提示：

• 链表中节点的数目范围是 [0, 5000]
• -5000 <= Node.val <= 5000

进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

来源：力扣（LeetCode）
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

本题与：剑指offer24.反转链表 一样

解题思路：

一、双指针（迭代）

设立两个指针节点，一个cur指向，初始指向head，一个pre，初始指向null，并设立一个临时节点temp用于保存cur的下一个节点，循环遍历链表，当cur为null时表示没有后续结点存在，停止循环，循环内做的事：

• 保存cur的下一个结点，存在temp中：temp = cur.next；
• 将当前cur的下一个指针指向pre：cur.next = pre；
• pre向前移动一位：pre = cur；
• cur向前移动一位：cur = temp

最后返回pre。

注意：为啥要先移动pre再移动cur，如果先先移动cur,cur = temp，pre的值再变为cur这时cur的值已经变了。

java代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        //申请两个指针,一个指向头结点一个指向空
        ListNode cur = head;
        ListNode pre = null;
        //设置一个临时变量来保存cur的下一个结点
        ListNode temp = null;
        //当cur为空表示没有后续结点时停止循环
        while(cur != null){
           temp = cur.next;
           cur.next = pre;
           //将pre和cur前进一位
           pre = cur;
           cur = temp;
        }
        return pre;
    }
}

 python3代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        cur = head
        pre = None
        
        while cur:
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp

        return pre

 二、递归

 递归看图解很好理解，但是看代码不是很好理解~ 参考@王尼玛大佬的题解和官方题解下各位大佬的注解

递归的两个条件：

• 终止条件是当前节点或者下一个节点为null(head == null || head.next == null)
• 在函数内部，改变节点的指向，即 head 的下一个节点指向 head ：head.next.next = head

递归函数中每次返回的 cur 其实只是最后一个节点，在递归函数内部，改变的是当前节点的指向。

递归本质是栈，从尾部向前构造，这里出栈要做的事就是建立反向连接并删除正向连接。

举例：1-->2-->3-->4-->5

第一轮：首先一直递归，直到遇到5时，下一个结点为空了，就返回结点5，此时head = 5，head.next = null；

第二轮：head为4，head.next为5，执行head.next.next=head,即5.next = 4


• 把当前节点的子节点的子节点指向当前节点，把5指向4；

• 此时链表为1->2->3->4<->5，由于4与5互相指向，所以此处要断开，即4.next=null；

• 此时链表为1->2->3->4<-5；

• 返回节点5

第三轮出栈：head为3，head.next为4，执行head.next.next=head,即4.next =3

• 把当前节点的子节点的子节点指向当前节点，把4指向3；

• 此时链表为1->2->3<->4<-5，由于3与4互相指向，所以此处要断开,即3.next=null；

• 此时链表为1->2->3<-4<-5；

• 返回节点5

第四轮出栈：head为2，head.next为3，执行head.next.next=head,即3.next =2

• 把当前节点的子节点的子节点指向当前节点，把3指向2；

• 此时链表为1->2<->3<-4<-5，由于2与3互相指向，所以此处要断开,即2.next=null；

• 此时链表为1->2<-3<-4<-5；

• 返回节点5

第五轮出栈：head为1，head.next为2，执行head.next.next=head,即2.next =1

• 把当前节点的子节点的子节点指向当前节点，把2指向1；

• 此时链表为1<->2<-3<-4<-5，由于1与2互相指向，所以此处要断开,即1.next=null；

• 此时链表为1<-2<-3<-4<-5；

• 返回节点5

出栈完成，最终头结点5->4->3->2->1

注意：这里的newhead结点5,就相当于于从1楼爬上五楼拿了一个苹果，然后又从5楼下楼，每下一层楼就展示一下这个苹果。

 java代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        //设置终止条件
        if(head == null || head.next == null) return head;
        //递归传入下一结点，到达尾结点
        ListNode newHead = reverseList(head.next);
        head.next.next = head;
        head.next = null;
       
        return newHead;
    }
}

 python3代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:
            return head
        
        newHead = self.reverseList(head.next)

        head.next.next = head
        head.next = None

        return newHead

2023-05-03日补充

递归（根据双指针的思路写出）

//递归
class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null) return null;
        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);
    }
}

栈：

//使用栈
class Solution {
     public ListNode reverseList(ListNode head) {
        //处理特殊情况
        if (head == null) return null;
        if (head.next == null) return head;
        //定义一个栈，让所有节点入栈
        Stack<ListNode> stack = new Stack<>();
        ListNode cur = head;
        while (cur != null){
            stack.push(cur);
            cur = cur.next;
        }
        //出栈
        //设置一个虚拟头结点
        ListNode dummyHead = new ListNode(0);
        cur = dummyHead;
        while (!stack.isEmpty()){
            ListNode node = stack.pop();
            cur.next = node;
            cur = cur.next;
        }
        cur.next = null;
        return dummyHead.next;
    }
}