day4|24. 两两交换链表中的节点 、19.删除链表的倒数第N个节点、02.07. 链表相交 、142.环形链表II

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

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

示例 1：

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

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

示例 2：

输入：head = []

输出：[]

示例 3：

输入：head = [1]

输出：[1]

 

问题分析：

①虚拟节点：设置一个虚拟节点。两个节点为一组，要找到每组结点的前一个节点， 来进行指针换向。 要设置两个留存指针，因为换向时会丢失指针（如图所示）

②迭代法

方法一：虚拟节点

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode node=new ListNode(-1,head);//虚节点
        ListNode cur=node;//虚节点指针
        ListNode temp1,temp2;//留存指针

        while(cur.next!=null&&cur.next.next!=null)//先判断cur.next!=null，否则会空指向
                                                    //不知道链表长度
                                                  //不需要用if判断是奇/偶数个
        {
            temp1 = cur.next;
            temp2 = cur.next.next.next;
            cur.next = cur.next.next;
            cur.next.next = temp1;
            temp1.next = temp2;
            cur = cur.next.next;

        }
        return node.next;//原始head有可能已经改变
    }
}

---

19.删除链表的倒数第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个结点。

但是，如果要删除一个节点，指针需要到删除节点的前一个节点 所以，需要让快指针比慢指针先走n+1步，这样慢指针就指向了被删节点的前一个节点。

这题主要看思路，有这个思路很快AC，但是不太容易想。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode node=new ListNode(-1,head);
        ListNode fast=node;
        ListNode slow=node;

        for(int i=0;i<n+1;i++){
            fast=fast.next;
        }
        while(fast!=null){
            slow=slow.next;
            fast=fast.next;
        }
        slow.next=slow.next.next;
        return node.next;

    }
}

---

02.07. 链表相交 

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

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

 

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

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

示例 1：

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

输出：Intersected at '8' 

解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。 从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。 在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

 示例 2：

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

输出：Intersected at '2' 

解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。 从各自的表头开始算起，链表 A 为 [0,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 

解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。 由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。 这两个链表不相交，因此返回 null 。

问题分析：

求出两个链表的长度，并求出两个链表长度的差值，然后让A组指针a移动到，和B组指针b末尾对齐的位置。

对齐后就可以比较A组指针a和B组指针b是否相同，如果不相同，同时向后移动a和b，如果遇到a==b，则找到交点。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode a=headA;//A组指针
        ListNode b=headB;//B组指针
        int sizeA=0;
        int sizeB=0;
        while(a!=null){
            sizeA++;
            a=a.next;
        }
        while(b!=null){
            sizeB++;
            b=b.next;
        }
        a=headA;
        b=headB;
        if(sizeB>sizeA){//防止再判断计算delen时，到底是A组链长还是B组链长
            int templen=sizeA;//交换链长
            sizeA=sizeB;
            sizeB=templen;
            ListNode tempnode=a;//交换组别，让a作为长链表的头
            a=b;
            b=tempnode;
        }
        int delen=sizeA-sizeB;


        while(delen-->0){//为了让A组和B组的队尾对齐
            a=a.next;
        }
        while(sizeB-->0) {//为了让A、B组的指针对齐
            if(a==b){//指针相同则输出节点
                return a;
            }
            a=a.next;
            b=b.next;

        }
        return null;
    }
}

---

 142.环形链表II

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

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

不允许修改 链表。

示例 1：

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

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

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

示例 2： 

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

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

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

示例 3：

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

输出：返回 null 

解释：链表中没有环。

问题分析：

 

定义快慢指针，先找环是否存在，再找环入口在哪。

①分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。 

②假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点再到环形入口节点节点数为 z。

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针，（y+z）为一圈内节点的个数.

因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z，

这就意味着，从头节点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。

让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是环形入口的节点。

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(fast==slow){//找到环了，开始找入口
            ListNode index1=fast;
            ListNode index2=head;
            while (index1!=index2){
                index1=index1.next;
                index2=index2.next;
            }
            return index1;
          }
      }
      return null;
    }
}