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

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

题目链接：24. 两两交换链表中的节点 - 力扣（LeetCode）

文档讲解：代码随想录 (programmercarl.com)

视频讲解：帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点_哔哩哔哩_bilibili

 思考：这道题目其实就是关于链表节点交换的模拟题目，重要的是：

1）使用虚拟头结点，将操作统一起来，会比较方便；

2）弄清楚交换的步骤，防止在交换过程中出现“断链”的问题。

模拟交换的步骤： 

图源：代码随想录

代码：

class Solution {
    public ListNode swapPairs(ListNode head) {
    
       ListNode dummyHead = new ListNode(0,head);//建一个虚拟头结点，统一操作
       ListNode cur = dummyHead;
       while(cur.next != null && cur.next.next != null){
        ListNode firstnode = cur.next;
        ListNode secondnode = cur.next.next;
        ListNode temp = secondnode.next;
        cur.next = secondnode;
        secondnode.next = firstnode;
        firstnode.next = temp;
        cur = firstnode;//移动cur，交换下一组节点
       }
       return dummyHead.next;
    }
}

时间复杂度：O(n)                   空间复杂度：O(1)  

tips: 将节点命名为：cur、firstnode、secondnode，比较清楚，防止在交换的时候出现混乱。 

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

题目链接：19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

文档讲解：代码随想录 (programmercarl.com)

视频讲解：链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点_哔哩哔哩_bilibili

思考：看到这个题目，优先想到的就是先遍历一遍获取到链表的元素个数，然后再在第二遍遍历时找到需要删除的节点，然后进行删除。

问题：那能不能通过一遍遍历就可以找到要被删除的节点呢？

答案：可以，使用双指针（快慢指针）。

双指针解法思路： 

       首先让快慢指针都指向虚拟节点，然后快指针先走n+1步，（因为在删除一个节点的时候，需要找到这个节点的前驱节点）所以意味着快慢指针要相差n+1个节点，之后，快慢指针同时移动，直至快指针指向null，此时，慢指针所指的节点就是被删节点的前驱节点。

 图源：代码随想录

代码：

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //双指针(快慢指针解法)
        ListNode dummyHead = new ListNode(0,head);//建虚拟头结点
        ListNode fast = dummyHead;
        ListNode slow = dummyHead;
        for (int i = 1; i <= n + 1; i ++){//fast指针先走n+1步
            fast = fast.next;
        }
        while(fast != null){//fast和slow指针同时移动
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;//执行删除操作
        return dummyHead.next;
    }
}

 时间复杂度：O(n)                   空间复杂度：O(1)  

链表相交

题目链接：

面试题 02.07. 链表相交 - 力扣（LeetCode）
文档讲解：

代码随想录 (programmercarl.com)

思路： 

1）遍历A、B链表求出两个链表的链表长度和差值；

2）让较长的链表先遍历完两者的差值；

3）比较当前两个节点是否相等，如果相等，返回当前这个节点，如果不相等，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。否则循环退出返回空指针。

代码：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode dummyHeadA = new ListNode(0,headA);
        ListNode dummyHeadB = new ListNode(0,headB);
        ListNode p = headA;
        ListNode q = headB;
        int lenA = 0;
        int lenB = 0;
        while(p != null){
            lenA ++;
            p = p.next;
        }
        while(q != null){
            lenB ++;
            q = q.next;
        }
        p = headA;
        q = headB;
        if(lenA > lenB){
            int gap = lenA - lenB;
            for(int i = 1; i <= gap; i++){
                p = p.next;
            }
        }else{
            int gap = lenB - lenA;
            for(int i = 1; i <= gap; i++){
                q = q.next;
            }

        }
        while(p != null && q!= null){
            if( p == q){
                return p;

            }else{
                p = p.next;
                q = q.next;
            }
        }
        return null;   
    }
}

时间复杂度：O（n + m)           空间复杂度：O（1）

Leetcode 142.环形链表II

题目链接：142. 环形链表 II - 力扣（LeetCode）
文档讲解：代码随想录 (programmercarl.com)
视频讲解：把环形链表讲清楚！ 如何判断环形链表？如何找到环形链表的入口？ LeetCode：142.环形链表II_哔哩哔哩_bilibili

如何判断链表是否有环？

       双指针思想，快慢指针。快指针每次移动两个节点，慢指针每次移动一个节点，如果快慢指针能够相遇，则说明链表有环，反之，无环。

注：为什么快指针每次移动两个节点，移动三个节点行不行？

移动三个节点有可能会跳过慢指针相遇的时刻，而每次移动两个节点，相对于慢指针而言，每次移动一个节点，这样就不会跳过相遇的时刻。

图源：代码随想录 

代码：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null || head.next == null){
            return null;
        }
        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;//index1记录相遇点
                ListNode index2 = head;
                while(index1 != index2)//寻找入口处
                {
                    index1 = index1.next;
                    index2 = index2.next;
                }
                 return index1;
        }
        }
        return null;
    }
}

时间复杂度：O(n)                   空间复杂度：O(1)