代码随想录【Day04】|24. 两两交换链表中的节点、19. 删除链表的倒数第 N 个结点、面试题 02.07. 链表相交、142. 环形链表 II

24. 两两交换链表中的节点

题目链接

题目描述：
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

再次强调单链表定义。

// Definition for singly-linked list.
     public static class ListNode {
         int val;
         ListNode next;
         ListNode() {}
         ListNode(int val) { this.val = val; }
         ListNode(int val, ListNode next) { this.val = val; this.next = next; }
     }

思路：
链的交换没什么问题，使用虚拟头节点更佳~~

难点：
注意边界情况的判断。

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

class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null) return head;
        ListNode dummy = new ListNode(-1, head);
        ListNode done = dummy; //已处理完毕的最后一个结点
        ListNode pre = dummy.next;
        ListNode cur = pre.next;
        ListNode post; //还未处理的第一个结点
        while (cur != null) { //满足可以交换
            post = cur.next;
            pre.next = post;
            done.next = cur;
            cur.next = pre;
            //交换完毕，更新各个临时结点指向（指针）
            done = pre;
            pre = done.next;
            if (pre == null || pre.next == null) { //剩余1个结点或剩余结点为空
                break;
            }
            cur = pre.next;
        }
        return dummy.next;
    }
}

时长：
15min

收获：
细心，不要忘记更新各个临时结点指向

---

19. 删除链表的倒数第 N 个结点

题目链接

题目描述：
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？

思路：
暴力思路就是先遍历一遍获得链表的size，然后再删除结点

一趟扫描：猜到要用双指针了，但是还是没想到位。
解决办法：如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

难点：
暴力：链表没有size属性，要删除倒数第n个结点，必须要遍历到第size-n个，需要两趟。

如何巧妙一趟获取到倒数第n个节点的位置？

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

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(-1, head);
        ListNode fast = dummy;
        ListNode slow = dummy;
        while (n-- != 0) { //快指针先移动n步
            fast = fast.next;
        }
        while (fast.next != null) { //同时移动快慢指针，直到slow到达删除点前一个
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        
        return dummy.next;
    }
}

时长：
20min

收获：
快慢指针思想的灵活运用

---

面试题 02.07. 链表相交

题目链接

题目描述：
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。

思路：
先获取两个链表长度
然后移动较长链表的临时结点，至两个链表剩余部分长度相同。

难点：
两个链表长度未知，需要先“对齐”链表后部分

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

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //获取两个链表长度
        int sizeA = 0;
        int sizeB = 0;
        ListNode pA = headA;
        ListNode pB = headB;
        while (pA != null) {
            sizeA++;
            pA = pA.next;
        }
        while (pB != null) {
            sizeB++;
            pB = pB.next;
        }
        //移动较长链表的临时结点，直到剩余部分与另一个链表长度相同
        int diffSize;
        pA = headA;
        pB = headB;
        if (sizeA >= sizeB) {
            diffSize = sizeA-sizeB;
            while (diffSize-- > 0) {
                pA = pA.next;
            }
        }else {
            diffSize = sizeB-sizeA;
            while (diffSize-- > 0) {
                pB = pB.next;
            }
        }
        while (pA != pB) {
            pA = pA.next;
            pB = pB.next;
        }
        return pA;
    }
}

时长：
20min

收获：
按部就班

---

142. 环形链表 II

题目链接

题目描述：
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。

思路：
这道题是有点难度的。
使用快慢指针
如果有环，快慢指针必相遇

难点：
如果有环，分析相遇结点的作用，对路径进行切分，找到环的入口。

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

public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                ListNode index1 = fast;
                ListNode index2 = head;
                while (index1 != index2) {
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }

时长：
40min

收获：
仔细分析，找突破口