代码随想录算法训练营Day4|Leetcode24两两交换链表中的节点、19删除链表的倒数第N个节点、142环形链表II、面试题 02.07. 链表相交

Day4打卡！ 时长：3h

今日感想：依旧是和链表、指针对抗的一天，对解题方法有一定的收获！除此之外我的数学能力是很弱的，有些题目理解起来要吃力！

Leetcode24 两两交换链表中的节点

题目链接：Leetcode24 两两交换链表中的节点

第一想法：感觉这个交换其实就是交换改变其值，指针方向应该不用动吧？使用一个中间变量存值做到两两交换试试。

讲解后想法：（又天真了，根本没仔细看题目😒......）首先，注意循环条件的写法，一定是cur->next不等于空并且cur->next->next不等于空的条件下执行循环语句，且两语句顺序也不能变，避免造成空指针。

遇到的问题：后面三个重要操作花了点时间理解。

代码：虚拟头节点+两临时指针版

/**
 * 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 swapPairs(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode cur = dummy;

        while (cur.next != null && cur.next.next != null){
            ListNode temp = cur.next;
            ListNode temp1 = cur.next.next.next;

            cur.next = cur.next.next;
            cur.next.next = temp;
            temp.next = temp1;
            
            cur = cur.next.next;
        }
        return dummy.next;
    }
}

Leetcode19 删除链表的倒数第N个节点

题目链接：Leetcode19 删除链表的倒数第n个节点

第一想法：我觉得这个题目应该先正过来，考虑倒数第n个是正数第几个，然后取到他前面那个节点，将其指针指向要删除的节点后面。

讲解后想法：大体思路是没错。首先要牢记，操作的节点涉及头节点，就引入虚拟头节点。其次，这道题用的方法是快慢指针。很巧妙：要想找到倒数第n个节点，说明该点和最后一个节点相差n个距离。利用快慢指针，先让快指针走n步，再同步移动快慢指针，直到快指针走到最后一个节点（此时fast->next = null）。

遇到的问题：感觉还可以~

代码：

/**
 * 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 removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;

        ListNode fastIndex = dummy;
        ListNode slowIndex = dummy;

        for(int i = 1; i <= n; i++){
            fastIndex = fastIndex.next;
        }

        while(fastIndex.next != null){
            fastIndex = fastIndex.next;
            slowIndex = slowIndex.next;
        }

        slowIndex.next = slowIndex.next.next;
        return dummy.next;
    }
}

Leetcode142 环形链表II

题目链接：Leetcode142 环形链表||

第一想法：要找链表中存在的环，说明要判断已经遍历到的某个点，在后面出现的指针又指向了它。

讲解后想法：依然是快慢指针的活，还涉及了数学问题。我只能说，这道题真滴难，以后还要反复琢磨的！

遇到的问题：这里我是真的没想到涉及数学问题，我的头疼项啊😫！

代码：

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(slow == fast){
                ListNode index1 = fast;
                ListNode index2 = head;
                while(index1 != index2){
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}

面试题 02.07. 链表相交

题目链接：面试题02.07 链表相交

第一想法：这道题乍一看就是判断两个链表从某个点开始为相同值的问题，感觉也是要多个指针来解决。（总感觉跟之前做的一个题很像，又想不起来......）

讲解后想法：关键点是“交点不是数值相等，而是指针相等”。不得不说，这个图一出，秒懂......但是我自己就是想不到捏......

遇到的问题：虽然思路清晰，但是操作起来感觉有点复杂。

代码：卡哥版

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != null) { // 求链表A的长度
            lenA++;
            curA = curA.next;
        }
        while (curB != null) { // 求链表B的长度
            lenB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            //1. swap (lenA, lenB);
            int tmpLen = lenA;
            lenA = lenB;
            lenB = tmpLen;
            //2. swap (curA, curB);
            ListNode tmpNode = curA;
            curA = curB;
            curB = tmpNode;
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap-- > 0) {
            curA = curA.next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != null) {
            if (curA == curB) {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }

}

评论区版：自古评论区出人才👍，这哥着实是在大气层！让两个指针分别走完a-b和b-a链表，这样也保证了长度相同，这样只需要判断有无相同点即可，还不会死循环。（感觉编程的尽头是巧妙地解决数学问题？）

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        
        ListNode h1 = headA, h2 = headB;

        while (h1 != h2) {

            h1 = h1 == null ? headB : h1.next;
            h2 = h2 == null ? headA : h2.next;
        }

        return h1;  
    }