前言

又是一波算法题...报告，先申明：我不是要跳槽，也不是在刷算法题。

就是单纯最近在看书，翻到了之前买的一些网课，拿出来读一读。发现还是挺有意思的，所以特定记录一下。

正文

今天的内容，还是延续上一篇队列的后续。先来一道基础题目热热身：

反转链表

反转链表这道题应该很多同学都做过，而且也是面试中的常客，所以直接上答案：

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}

没啥特别好说的：两个变量，一个记录当前，一个记录前一个。遍历链表，让当前的next指向前一个，更新当前 / 前一个 就好了。

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode p = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return p;
    }
}

递归实现有一个比较棘手的问题需要解决：如何把上一个递归栈内的节点指向 反转中链表的尾部。这个问题重点在于理解：head.next.next = head; head.next = null;。

这段代码做了俩件事情：

• 1.反转的两个链节点
• 2.切断了head.next

这样对于上一个递归栈内的head通过head.next.next = head，``head.next.next`此时为null，因为已经被下一个递归栈内的代码切断。此时直接指向自己，就是把自己挂到了已经反转好的链表上了。

环形链表

image.png

image.png

链表中有环，就意味着某个节点的next指向了这个节点的前驱某个节点。所以解题思路也就基本有了：遍历节点，如果当前节点在之前遍历过那么就有环...

以这个思路单纯解决问题，是在是太简单了。题目中有一个进阶部分：空间复杂度O(1)，所以咱们记录遍历过的节点，那就肯定没办法O(1)...转念一想也很简单：咱们上边的方案是空间换时间，既然空间不允许，那咱们就时间换空间。

思路：一个变量cur记录当前节点，一个变量n定为当前.next，负责往后遍历。n走完一遍，cur往下走，n继续遍历。当n遍历的过程中发现和cur相同，那么就有环。但是这种方案提起来就有点慢..

其实咱们上述的思路都想复杂了。环形有一个啥特点？两个速度一样的单位一定为相交，咱们只需要选取最小的速度差即可，俩个节点就可以成环。所以问题就解了...

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                return true;
            }
        }
        return false;
    }
}

尾声

其实今天的题目都很基础，但是为啥还是记录下来了呢？主要还不是因为自己菜，看完之后觉得“恍然大悟”，所以就把自己思考的过程记了一下。

大家就取其精华去其糟粕吧。与君共勉~