代码随想录：链表6-8

19.删除链表的倒数第n个节点

题目

        给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

代码

/**
 * 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 dummyhead = new ListNode(-1,head); //虚拟头结点
        ListNode fast = dummyhead;
        ListNode slow = dummyhead;
        while(n-- > 0){  
            fast = fast.next;  //快指针先移动n步
        }
        while(fast.next != null){  
            //当快指针指向最后一个节点时，慢指针指向删除节点的前一个节点
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;  //删除slow的后边一个节点
        return dummyhead.next; //返回头结点

    }
}

总结

1.思想：要删除倒数第n个节点，就让fast先走n步，然后slow和fast一起走，直到fast指向最后一个节点，此时slow指向的正好是待删除节点的前一个节点。

2.注意点：fast.next != null，不能少next，因为fast要指向最后一个节点时，slow指向待删除节点的前一个，fast如果指向null了，slow已经是要删除的节点了，多走了一步。

第二次刷题总结

1.由于可能会删除第一个节点，因此需要加一个虚拟头结点方便操作，这个一下子没想起来。

2.后边的流程就是，删除倒数第几个，就让fast先走n步，然后让fast走到最后一个节点时，slow正好走到要删除节点的头一个节点。fast最后停止的位置是最后一个节点，所以循环终止条件是fast.next!=null。

面试题02.07. 链表相交

题目

        给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        //ListNode curB = headA; 这里笔误了
        ListNode curB = headB;
        int lenA = 0;
        int lenB = 0;
        //计算headA的长度
        while(curA != null){
            curA = curA.next;
            lenA++;
        }
        //计算headB的长度
        while(curB != null){
            curB = curB.next;
            lenB++;
        }
        //让curA和curB恢复到指向链表的头节点
        curA = headA;
        curB = headB;
        //保证lenA和curA指向的是长一点的链表
        if(lenA < lenB){
            //swap(lenA,lenB);这样写会报错
            int tmp = lenA;
            lenA = lenB;
            lenB = tmp;
            //swap(curA,curB);这样写会报错
            ListNode tmpNode = curA;
            curA = curB;
            curB = tmpNode;
        }
        int k = lenA - lenB; //计算链表长度的差值
        while(k-- > 0){
            curA = curA.next; //让curA指向和curB同时开始的位置
        }
        while(curA != null){
            if(curA == curB){
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        // return; 不能这样写会报错
        return null;
        
    }
}

总结

1.思想：要找到两个链表何时相交，返回相交的节点。先计算两个链表的长度，其差值为k，让长一点的链表指针curA移动k步，这是保证了curA和curB后边的结点对应了，然后遍历链表，逐个判断是否相同，相同则返回当前节点，都不相同返回cur。

2.注意点

（1）计算链表长度时，用curA != null，因为cur是空节点时，整个链表才算变量完成，如果用curAt.next!=null，最后一个节点不会计算到长度里。

（2）计算完长度之后，curA和curB都是null了，需要重新赋值给headA和headB。

（3）lenA和lenB计算后，需要继续交换，保证LenA和curA是更长的链表。

3.语法错误

（1）ListNode curB = headA; 使用自动补全的时候要看清楚，是不是补了自己要的变量。

（2）调用swap函数，要把头文件加上，不能直接用。

（3）最后是return null；不是return；

第二次刷题总结

1.出现了两个错误。

        第一，遍历计算链表长度后，curA和curB要重新指向头结点，这里忘记了。

        第二，判断链表某个节点相同，用的是curA == curB，而不是curA.val == curB.val。因为链表相交代表的是内存地址一样，因此必须直接用节点进行比较，而不是节点的存储值。

2.再梳理一下核心算法。其实就是先计算两个链表的长度，让长一点的先移动k步。然后从后边的部分两两比较。

142.环型链表II

题目

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

代码

/**
 * 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;
        //循环终止条件很重要，当前节点和下一节点都不是空，fast才能走两步
        while(fast != null && fast.next != null){
            fast = fast.next.next; //快指针每次走两步
            slow = slow.next; //慢指针每次走一步
            if(fast == slow){  //说明有环
                ListNode index1 = fast; //index1保存相遇节点
                ListNode index2 = head; //index2指向头结点
                while(index1 != index2){ //让x和z在环入口相遇
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;  //返回环入口
            }
        }
        return null; //没有环，返回空
        
    }
}

总结

1.思想：首先判断链表有没有环，用快指针fast走两步，慢指针slow走一步，如果有环，快指针会提前进入环，等slow进入环之后，逐渐节点slow相遇，所有如果有环，slow和fast会相等，此时是相遇节点。然后如何得到环的入口节点，根据x = （n-1）(y+z)+z，得到头结点到入口节点=相遇节点到入口节点，因此可以用index1等于相遇节点，index2等于头结点，直到index1==index2，返回入口节点。如果没有环，相当于fast指针会提前为空，此时并没有相遇节点return，最后返回是null。

2.核心思路：用快慢指针是否相遇表示有没有环，用相遇节点和头结点重合代表环的入口。

3.注意点：

（1）循环的终止条件是fast!=null&&fast.next!=null，代表如果当前节点是空已经是-1节点，或者当前节点的指针是空表示当前节点时最后一个节点时，不再进行迭代，fast已经到最后一个节点or-1个节点了，说明不可能有环了。

（2）没有环的return null;要放在最外面，只有fast!=null&&fast.next!=null循环终止，说明没有环。

第二次刷题总结

1.出错点在判断环的while循环条件fast != null && fast.next != null，多写了一个next。

        第一种理解方法，fast是对链表进行遍历的，且两步一跳。只有fast对链表遍历完我们才能保证没有环。如果是奇数个节点，fast最后指向会最后一个节点，此时fast.next == null。如果是偶数个节点，最后fast会指向-1个空节点，此时fast==null。

        第二种理解方法，比较暴力。因为while循环内部要执行fast = fast.next.next，因为要保证这个语句编译不出错，fast不会越界，fast以及fast.next都不能为null，才能保证 fast.next.next有意义。