从小白开始刷算法 ListNode 链表篇 leetcode.206

序言：
虽然算法很难，但不应该就放弃。

先自己尝试写，大概十几分钟仍然写不出来
看思路，再尝试跟着思路写
仍然写不出来，再看视频
b站up视频推荐：爱学习的饲养员

leetcode其他文章：

数组篇：
从小白开始刷算法 数组篇 leetcode.485
从小白开始刷算法 数组篇 leetcode.283
从小白开始刷算法 数组篇 leetcode.27
链表篇：
从小白开始刷算法 ListNode 链表篇 leetcode.203

链表篇
难度：简单

题目：

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

示例 1:

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

示例 2:

输入：head = [1,2]
输出：[2,1]

//ListNode 节点
 class ListNode {
     int val;
     ListNode next;
     ListNode() {}
     ListNode(int val) { this.val = val; }
     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 }
//这个是int列表转ListNode节点，在网上找不到
//本地测试时候需要使用，自己写的小工具的ヾ(≧▽≦*)o
public static ListNode arrayToListNode(int[] a){
    ListNode head=new ListNode(a[0]);
    ListNode temp;
    temp = head;
    for (int i = 1; i < a.length; i++) {
        ListNode a1 = new ListNode(a[i]);
        temp.next = a1;
        temp = a1;
    }
    return head;
}

能否写出：能写出来

时间：20分钟在画图，10分钟写代码，30分钟在改代码

思路：难啊，这是简单题？

• 初始化三个指针：prev、curr 分别指向前一个节点、当前节点。

• 遍历链表，每次迭代将当前节点的指针指向前一个节点，然后更新三个指针的位置，继续遍历。

• 最后返回新的头节点，即原链表的尾节点。

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            //暂存下一个节点
            ListNode temp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = temp;
        }
        return prev;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

当然还有递归来解决，但我看迷糊了，先存着，等我之后清醒点再看的(ToT)/~~~

• 递归地反转子链表，然后将当前节点的指针指向前一个节点。
• 基本情况是当链表为空或只有一个节点时，直接返回该节点。
• 最后返回递归调用的结果，即新的头节点。

递归法的代码：

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;  // 返回新的头节点
}