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

day04：24.两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题02.07.链表相交、142.环形链表II

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

题目链接：

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

文章讲解：

https://programmercarl.com/0024.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9.html

视频讲解：

https://www.bilibili.com/video/BV1YT411g7br/

思路和解法：

虚拟头结点

1、使用虚拟头结点的原因：不需要对头结点进行特殊判断，方便用统一的规则对节点进行处理，如在本题中，如果要反转相邻的两个节点，那么要操作的指针一定要指向要反转两个节点的前一个节点

2、遍历结束条件：

当链表的节点数为奇数的时候，cur.next.next为空时，结束

当链表的节点数为偶数的时候，cur.next为空，结束

3、交换节点：

使用临时节点tmp保存交换前两个节点中的第一个节点

使用临时节点tmp1保存两个节点后面的节点

修改节点指向，参考下图：

交换完毕后，cur移动，准备下一轮交换

public class Solution {
    public ListNode SwapPairs(ListNode head) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode cur = dummyHead;
        while(cur.next != null && cur.next.next != null)
        {
            ListNode tmp = cur.next;
            ListNode tmp1 = cur.next.next.next;
            cur.next = cur.next.next;//步骤一
            cur.next.next = tmp;//步骤二
            tmp.next = tmp1;//步骤三
            cur = cur.next.next;
        }
        return dummyHead.next;
    }
}

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

题目链接：

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

文章讲解：

https://programmercarl.com/0019.%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B9.html

视频讲解：

https://www.bilibili.com/video/BV1vW4y1U7Gf/

思路和解法：

双指针法：

定义快慢指针：

快指针fast：先走N+1步，与慢指针之间间隔N个节点之所以是N+1步，是因为如果要对节点进行删除操作，当前指针一定要指向要删除的节点的前一个节点。

慢指针slow：当快指针走N+1步之后，和快指针一起移动

当快指针fast指向null的时候，慢指针slow则会指向要删除节点的前一个节点，此时将slow.next指向slow.next.next完成删除操作

public class Solution {
    public ListNode RemoveNthFromEnd(ListNode head, int n) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode fast = dummyHead;
        ListNode slow = dummyHead;
        //快指针先走N+1步，与慢指针之间间隔N个节点
        for(int i = 0; i < n + 1; i++)
        {
            fast = fast.next;
        }
        while(fast != null)
        {
            fast = fast.next;
            slow = slow.next;
        }

        slow.next = slow.next.next;

        return dummyHead.next;
    }
}

LeetCode 面试题02.07.链表相交

题目链接：

面试题02.07.链表相交

文章讲解：

https://programmercarl.com/%E9%9D%A2%E8%AF%95%E9%A2%9802.07.%E9%93%BE%E8%A1%A8%E7%9B%B8%E4%BA%A4.html

思路和解法：

如果两个链表有交点，那么从交点开始往后的节点是相同的，那么就有了以下思路：

1、两个链表分别为A、B（A的长度大于B），定义指针curA和curB，分别指向A和B的头结点。

2、求出A、B两个链表的长度，并求出差值gap，然后让curA移动到链表A与链表B末尾对其的位置，如图：

3、此时就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点，否则退出循环，返回空。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode GetIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int lenA = 0, lenB = 0;
        while(curA != null) //求A链表的长
        {
            lenA++;
            curA = curA.next;
        }
        while(curB != null) //求B链表的长
        {
            lenB++;
            curB = curB.next;
        }

        //求出长度后，curA和curB重新指向对应头结点
        curA = headA;
        curB = headB;

        // 让curA为长链表的头，lenA为其长度
        if(lenA < lenB)
        {
            //交换长度
            int tmpLen = lenA;
            lenA = lenB;
            lenB = tmpLen;

            //交换头结点
            ListNode tmpNode = curA;
            curA = curB;
            curB = tmpNode;
        }

        //求长度差
        int gap = lenA - lenB;
        
        //让两个链表末尾对其，将curA移动到和curB同一起点上
        while(gap-- > 0)
        {
            curA = curA.next;
        }
        while(curA != null)
        {
            if(curA == curB)
                return curA;
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}

LeetCode 142.环形链表II

题目链接：

142.环形链表II

文章讲解：

https://programmercarl.com/0142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II.html

视频讲解：

https://www.bilibili.com/video/BV1if4y1d7ob/

思路和解法：

链表中的环：是指链表中出现指向自己或指向自己之前的元素，从而使链表形成一个闭环的状态。

双指针法：

1、判断链表是否有环：

定义快慢指针，都从头结点触发，快指针每次走两个节点，慢指针每次走一个节点。

如果链表无环，则快慢指针绝对不可能相遇。

如果链表有环，则快指针进入环后会一直在转圈，然后慢指针也逐渐进入环，也开始转圈了，但因为定义的快指针每次走两个节点，慢指针每次走一个节点，两个都进入环后，快指针相对于慢指针移动的话，是一个节点一个节点的去靠近慢指针，所以快慢指针一定会相遇。

2、如何找到环的入口：

记录快慢指针相遇的位置

public class Solution {
    public ListNode DetectCycle(ListNode head) {
        if(head == 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)//快慢指针相遇，代表有环
            {
                slow = head;//慢指针回到头结点
                while(slow != fast)
                {
                    slow = slow.next;
                    fast = fast.next;
                }
                return fast;
            }
        }
        return null;
    }
}

ad;//慢指针回到头结点
while(slow != fast)
{
slow = slow.next;
fast = fast.next;
}
return fast;
}
}
return null;
}
}