两两交换的链表中的节点，删除链表的倒数第 n 个结点，相交链表，环形链表II

两两交换的链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

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

输出：[2,1,4,3]

示例 2：

输入：head = []

输出：[]

示例 3：

输入：head = [1]

输出：[1]

这道题目要两两交换链表，不过都是针对偶数下标的节点而言，不过因为要交换两个链表中的节点，要知道的是这两个节点之前的那个节点。

class Solution {
    public ListNode swapPairs(ListNode head) {
         ListNode dummyHead = new ListNode(-1, head);
         ListNode cur = dummyHead;
         while(cur.next != null && cur.next.next != null) {
             ListNode a1 = cur.next;
             ListNode a2 = cur.next.next;
             cur.next = a2;
             a1.next = a2.next;
             a2.next = a1;
             cur = cur.next.next;
         }
         return dummyHead.next;
    }
}

删除链表的倒数第 n 个结点

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

示例 1：

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

输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1

输出：[]

示例 3：

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

输出：[1]

这道题目中，要删除倒数的第n个节点，在我们常识中，倒数是要从后面往前面数的，所以这就限制两我们的思想，我们可以设置两个指针，其中一个指针先往前面运动n个距离，然后两个指针一起移动，知道前面的指针到达末尾，这是后面的指针所指的节点就是我们要删除的节点了。真的是十分得巧妙。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyHead = new ListNode(-1, head);
        ListNode pre = dummyHead;
        ListNode fast = dummyHead;
        ListNode slow = head;
        for(int i = 0; i < n; i++) {
            fast = fast.next;
        }
        while(fast.next != null) {
            fast = fast.next;
            slow = slow.next;
            pre = pre.next;
        }
        pre.next = slow.next;
        slow.next = null;
        return dummyHead.next;
    }
}

相交链表

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

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3

输出：Intersected at '8'

解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。

从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。

在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例 2：

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1

输出：Intersected at '2'

解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。

从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。

在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2

输出：null

在这道题中，我是先算出两个链表的长度之差n，然后让较长的链表的头节点指针再向前移动n步，然后两个链表指针同时移动，如果相同则返回，不同则返回null。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int lengthA = getLength(headA);
        int lengthB = getLength(headB);
        int n = Math.abs(lengthA - lengthB);
        if(lengthA > lengthB) {
            for(int i = 0; i < n; i++) {
                curA = curA.next;
            }
        }else {
            for(int i = 0; i < n; i++) {
                curB = curB.next;
            }
        }
        while(curA != null) {
            if(curA == curB) {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
    private int getLength(ListNode head) {
        int count = 0;
        while(head != null) {
            head = head.next;
            count++;
        }
        return count;
    }
    
}

环形链表II

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

示例 1：

输入：head = [3,2,0,-4], pos = 1

输出：返回索引为 1 的链表节点

解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0

输出：返回索引为 0 的链表节点

解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1

输出：返回 null

解释：链表中没有环。

关于这道题有两个要点：

  1.判断链表是否有环。

  2.找到入环节点。

对于第一点，我们可以设置快慢指针，快指针f以步长为2进行运动，慢指针s以步长为1进行运动，如果链表中有环，它们必会在环内相遇。

对于第二点，看示例：

上述为s与f第一次相遇的图片，如果设整个链表的节点个数为a+b，a为链表头到入环节点的个数，b为环内节点的个数，所以f = s + nb，n为f指针在环内运动的圈数，又因为f = 2s 所以，s = nb如果这时有个指针从头节点出发，那么要到达入环节点所有过的距离就是a+nb，也就是说，s指针再走a步，就会到达入环节点。

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