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

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

题目链接/文章讲解/视频讲解： 代码随想录

如上图所示，两两交换链表中的元素实际是要将链表指针顺序改为红色线所示。需要注意的是，在更改指针指向时，会出现节点没有被指针指向的情况，例如在第一步由0指向2时，1节点失去了指向他的指针，所以应该在出现这种情况时，先一步用临时节点存储该节点。所以，实际代码的实现步骤应该如下图所示。

实际的代码中分为了五步，在图中也标注了原本黑色的指向在哪一步中消失。

1. 1、将1暂存
2. 2、将0指向2，此时0指向1消失
3. 3、将3暂存
4. 4、将2指向1，此时2指向3消失
5. 5、将1指向3，此时1指向2消失（但2已经可由0指向，不需要暂存）

经过5步完成了在cur在0时，对1和2的位置交换，随后将cur改为temp（即相对于下面两个元素的0结点）即可进入下一轮循环。

循环条件：cur.next 和 cur.next.next 均不为空，注意先判断前者并使用短路与，否则后者会出现空指针异常。

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode cur = dummy;
        ListNode temp = null;
        ListNode temp1 = null;
        while(cur.next != null && cur.next.next != null){
            temp = cur.next;
            cur.next = temp.next;
            temp1 = cur.next.next;
            cur.next.next = temp;
            temp.next = temp1;
            cur = temp;
        }
        return dummy.next;
    }
}

递归法

根据上述的方法自己写了一版递归法，还是利用了虚拟头结点。

class Solution {
    
    ListNode temp = null;
    ListNode temp1 = null;

    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        swapNode(dummy);
        return dummy.next;
    }

    public void swapNode(ListNode cur){
        if(cur.next == null || cur.next.next == null){
            return;
        }
        temp = cur.next;
        cur.next = temp.next;
        temp1 = cur.next.next;
        cur.next.next = temp;
        temp.next = temp1;
        swapNode(temp);
    }
}

看了答案是一种没有虚拟头结点的方法，相当简洁。

直接看代码不好理解，通过一步一步推导梳理了一下递归过程。

在两个元素互换过程中，将要指向的下个节点用递归函数来表示，递归函数里返回的是本次递归中的头节点。在进入递归的过程中是从链表的头部往尾部每两个节点一次递归的往尾部找，找到最后需要交换的两个元素（单个就返回自己），完成交换后将头节点往前返回，前面的递归函数需要拿到下一个节点（深层递归里返回的头节点）才能完成交换。

感觉现在理解了，后续自己也很难写出这种方法，希望以后回看时就觉得简单了。

// 递归版本
class Solution {
    public ListNode swapPairs(ListNode head) {
        // base case 退出提交
        if(head == null || head.next == null) return head;
        // 获取当前节点的下一个节点
        ListNode next = head.next;
        // 进行递归
        ListNode newNode = swapPairs(next.next);
        // 这里进行交换
        next.next = head;
        head.next = newNode;

        return next;
    }
} 

---

二、19.删除链表的倒数第N个节点

题目链接/文章讲解/视频讲解：代码随想录

看完视频对快慢指针法的过程清楚了，但是具体写的时候还是把循环次数写错，最后删除元素也没有判断空指针异常。

当同时移动时的判断条件为fast.next时，就仅需将快指针移动n次，慢指针所停位置就是待删元素前一个节点。若判断条件为fast != null则快指针需要移动n+1次。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode fummy = new ListNode(0);
        fummy.next = head;
        ListNode fast = fummy;
        ListNode slow = fummy;
        while(n != 0){
            fast=fast.next;
            n--;
        }
        while(fast.next != null){
            fast = fast.next;
            slow = slow.next;
        }
        if(slow.next != null){
              slow.next=slow.next.next;
        }
      
        return fummy.next;
    }
}

---

三、面试题 02.07. 链表相交

题目链接/文章讲解：代码随想录

第一种思路是先移动较长的链实现两个链同步，因为如果两个链有相交，相交后面的节点是共用的，所以从相交的位置后面的节点是重复的。所以要把两个链进行尾部对齐，再从短链的头节点依次判断是否有相同节点。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int sizeA = 0;
        int sizeB = 0;
        if(headA == null || headB == null){
            return null;
        }
        //统计A的长度
        while(curA != null){
            curA = curA.next;
            sizeA++;
        }
        //统计B的长度
         while(curB != null){
            curB = curB.next;
            sizeB++;
        }
        curA = headA;
        curB = headB;
        if(sizeA > sizeB){
            for(int i = 0 ; i<(sizeA - sizeB) ; i++){
                curA = curA.next;
            }
        }else if(sizeB > sizeA){
             for(int i = 0 ; i<(sizeB - sizeA) ; i++){
                curB = curB.next;
            }
        }

        while(curA != null && curB !=null){
            if(curA == curB){
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}

第二种思路是用指针走完一个链表就从另一个链表开始，如下图所示，如果两个链表有相交节点，则这种方式就能走到共同节点停止循环，如果没有共同节点，则会走过a+b后都走到null，也会相等，从而结束循环。此时，输出相同节点（没有就会是null）即可。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode a = headA, b = headB;
        while(a != b){
            if(a == null) a=headB;
            else a = a.next;
            if(b == null) b=headA;
            else b = b.next;
        }
        return a;
    }
}

---

四、142.环形链表II

题目链接/文章讲解/视频讲解：代码随想录

判断是否有环：快指针一次走两个节点，慢指针一次走一个节点，能相遇则有环。

环形入口节点：还是通过快慢指针，通过运算来找到环形入口节点位置。

如图所示设变量，因为慢指针进入环中以后，一定没有还没有走完一圈就和快指针相遇了（因为如果慢指针走了一圈，快指针一定走了两圈，不合理），所以 x+y 就是慢指针走过的距离。

快指针则可能已经绕了多圈才相遇，快指针走过的距离是 x+y+n(z+y) ,快指针一定走了一圈以上：n >= 1。

快指针是慢指针速度的2倍，则 2(x+y) = x+y+n(z+y)   ==>   x = n(z+y) -y  ==>  x = (n-1)(z+y) +z

等式表明，我们让两个指针分别从头结点和相遇结点开始以一个结点的速度走，会在环形入口点相遇。

z+y是快指针在环内走过的圈数（起点在相遇点），如果x距离很长，环很小，当头结点的指针走过x进入环时，环中的指针确实可能绕了很多圈，但总共走过的距离会是  z + (n-1)圈，会在环形入口点与头结点出发的指针相遇，即可找到环形入口点位置。

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 cur = head;
                while(cur != fast){
                    cur = cur.next;
                    fast = fast.next;
                }
                return cur;
            }
        }
        return null;
    }
}

五、链表总结

理论基础

• 链表的种类主要为：单链表，双链表，循环链表
• 链表的存储方式：链表的节点在内存中是分散存储的，通过指针连在一起。
• 链表是如何进行增删改查的。
• 数组和链表在不同场景下的性能分析。