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

打卡Day5

1.24.两两交换链表中的节点
2.19.删除链表的倒数第N个节点
[3.面试题 02.07. 链表相交](#3.面试题 02.07. 链表相交)
4.142.环形链表II

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

java 复制代码

class Solution {
    public ListNode swapPairs(ListNode head) {
        //虚拟节点
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode cur = dummy;
        ListNode temp;//保存第三个节点
        ListNode firstNode;//保存第一个节点
        ListNode seconfNode;//保存第二个节点
        while(cur.next != null && cur.next.next != null){
            temp = cur.next.next.next;
            firstNode = cur.next;
            seconfNode = cur.next.next;
            cur.next = seconfNode;
            seconfNode.next = firstNode;
            firstNode.next = temp;
            cur = firstNode;
        }
        return dummy.next;
    }
}

java 复制代码

//改变互换的步骤顺序
class Solution {
    public ListNode swapPairs(ListNode head) {
       ListNode dummy = new ListNode(0,head);
       ListNode cur = dummy;
       while(cur.next != null && cur.next.next != null){
        ListNode node1 = cur.next;
        ListNode node2 = cur.next.next;

        cur.next = node2;
        node1.next = node2.next;
        node2.next = node1;

        cur = node1;
       }
       return dummy.next;
    }
}

递归法：

首先写边缘条件

java 复制代码

if(head == null || head.next == null){
        return head;
       }

将1节点和2节点相互交换，先将next.next指向head，head.next指向新节点，然后返回2节点。而递归就在于将后移，以第一次为例进行说明，输入head（节点1）返回节点2，那么下一次，则需要输入3节点，输出4节点，即为next.next。

java 复制代码

class Solution {
    public ListNode swapPairs(ListNode head) {
       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;
    }
}

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

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

文档讲解：代码随想录

java 复制代码

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //新建虚拟节点
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        
        ListNode fastNode = dummy;
        ListNode slowNode = dummy;
        
        for(int i = 0; i <= n; i++){
            fastNode = fastNode.next;
        }

        while(fastNode != null){
            fastNode = fastNode.next;
            slowNode = slowNode.next;
        }

        if(slowNode.next != null){
            //避免空指针异常
            slowNode.next = slowNode.next.next;
        }
        
        return dummy.next;
    }
}

3.面试题 02.07. 链表相交

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

文档讲解：代码随想录

java 复制代码

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int countA = 0;
        int countB = 0;
        ListNode curA = headA;
        ListNode curB = headB;

        while(curA != null){
            countA++;
            curA = curA.next;
        }
        while(curB != null){
            countB++;
            curB = curB.next;
        }

        curA = headA;
        curB = headB;
        
        //让A变为长链
        if(countB > countA){
            int tem = countA;
            countA = countB;
            countB = tem;

            ListNode temp = curA;
            curA = curB;
            curB = temp;

        }

        int cha = countA - countB;
        while(cha > 0){
            curA = curA.next;
            cha--;
        }

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

            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}

两个注意点：

（1）查找的交点并不是找值相同的节点，而是找指针相同的节点。通过将两个链表后靠齐，然后移动长链表的开始指针到差值处，就可以比较curA和curB是否相同。

（2）关于A和B谁长的问题，两种情况，想让A链永远长，那就可以在B长的时候进行AB对换。

4.142.环形链表II

题目链接：环形链表II

文档讲解：代码随想录

（1）如何想到用快慢指针：如果链表无环，则快慢指针永远无法相遇。一旦快慢指针相遇，则说明一定存在有环。

（2）快指针无法越过慢指针继续打转（即快指针一定是在慢指针一圈没有走完的情况遇到了慢指针）：慢指针进入环，快指针步速为2，相对于慢指针的步速1，是一次一步的靠近慢指针，肯定无法错过慢指针。假设慢指针走完一圈，以快指针的速度，已经走完两圈了，一定会在圈内超过慢指针。

慢指针：x+y

快指针：x+y+n(y+z)

n：表示快指针在环内走的圈数

因为相遇，所以可以得到等式：2（x+y）= x+y+n（y+z）

两边约掉x+y，可得：x+y = n（y+z）=（n-1）（y+z）+ y+z

所以x = （n-1）（y+z）+z

由于y+z是定值，我们可以以n=1的特例看出，当快慢指针相遇后，x = z，从相遇的时间开始算起，从head以及相遇点同时出发的指针会在入口处相遇，就可以得到入环点。

java 复制代码

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 = slow;
                ListNode index2 = head;

                // if(index1 == index2){
                //     return index1;
                // }

                // index1 = index1.next;
                // index2 = index2.next;

                while(index1 != index2){
                    index1 = index1.next;
                    index2 = index2.next;
                }

                return index1;

            }
        }
        return null;
    }
}

关于

java 复制代码

 // if(index1 == index2){
 //     return index1;
 // }

// index1 = index1.next;
// index2 = index2.next;

我一开始用的if，在力扣里面显示超过时间限制，原因是if在快慢指针相遇的时候只判断了一次index1 == index2，一般情况下是不等的，所以会死循环。

感觉这道题，难在思路。有时候，自己写思路想不到；看了思路，代码不会写。学代码真痛苦！