代码随想录 day 4

第二章 链表part02

今日任务

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

详细布置

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

用虚拟头结点，这样会方便很多。
本题链表操作就比较复杂了，建议大家先看视频，视频里我讲解了注意事项，为什么需要temp保存临时节点。
题目链接/文章讲解/视频讲解： 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

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

双指针的操作，要注意，删除第N个节点，那么我们当前遍历的指针一定要指向 第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

面试题 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

142.环形链表II

算是链表比较有难度的题目，需要多花点时间理解 确定环和找环入口，建议先看视频。
题目链接/文章讲解/视频讲解：https://programmercarl.com/0142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II.html

总结

对于链表的题目，大家最大的困惑可能就是 什么使用用虚拟头结点，什么时候不用虚拟头结点？
一般涉及到 增删改操作，用虚拟头结点都会方便很多， 如果只能查的话，用不用虚拟头结点都差不多。
当然大家也可以为了方便记忆，统一都用虚拟头结点。
https://www.programmercarl.com/%E9%93%BE%E8%A1%A8%E6%80%BB%E7%BB%93%E7%AF%87.html

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

题目链接

https://leetcode.cn/problems/swap-nodes-in-pairs/description/

解题思路

保持处理逻辑一样，虚拟头节点
这样会方便很多，要不然每次针对头结点（没有前一个指针指向头结点），还要单独处理。
自己画图看下，每次交换的逻辑，周而复始，很容易就写出来了。

code

    //建议使用虚拟头结点，这样会方便很多，要不然每次针对头结点（没有前一个指针指向头结点），还要单独处理。
    //自己画图看下，每次交换的逻辑，周而复始
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next ==null){
            return head;
        }
        ListNode dummyNode=new ListNode(0);
        dummyNode.next=head;
        ListNode pre=dummyNode;
        ListNode cur=dummyNode.next;
        while(cur!=null&&cur.next!=null){
            //下一轮的cur节点
            ListNode nextCur=cur.next.next;
            //交换的节点
            ListNode cur2=cur.next;
            cur2.next=cur;
            cur.next=nextCur;//
            pre.next=cur2;
            pre=cur;
            cur=nextCur;
        }
        return dummyNode.next;
    }

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

题目链接

https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/

解题思路

使用虚拟头结点，这样方便处理删除实际头结点的逻辑，这样即使删除头节点和删除其他节点逻辑仍然一致。
双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

code

public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummyNode=new ListNode(0);
    dummyNode.next=head;
    ListNode slow=dummyNode;
    ListNode fast=dummyNode;
    while(n-->=0){//多运行向后走一步，以便slow提前一步，这时候slow下一个节点就是要删除的节点。
        fast=fast.next;
    }
    while(fast!=null){
        slow=slow.next;
        fast=fast.next;
    }
    slow.next=slow.next.next;
    return dummyNode.next;
}

面试题 02.07. 链表相交

题目链接

https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/description/

解题思路

如果链表相交 链表后面的引用一定相等
求出链表A和链表B的长度，把长链表的指针移动到这俩个链表的差值位置比
headA指针和headB指针 如果出现相等则链表相交否则不相交。

code

//如果链表相交 链表后面的引用一定相等
    //求出链表A和链表B的长度，把长链表的指针移动到这俩个链表的差值位置比较是否相等
    //headA指针和headB指针 如果出现相等则链表相交否则不相交。
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //求出俩个链表的长度
        int a=0;
        int b=0;
        ListNode head1=headA;
        ListNode head2=headB;
        while(head1!=null){
            head1=head1.next;
            a++;
        }
        while(head2!=null){
            head2=head2.next;
            b++;
        }
        //移动长链表指针到差值位置
        int c=0;
        if(a>b){
            c=a-b;
            while(c-->0){
                headA=headA.next;
            }
        }else{
            c=b-a;
            while(c-->0){
                headB=headB.next;
            }
        }
        //比较俩个链表是否相等，相等就有交点否则没有。
        while(headA!=null&&headB!=null){
            if(headA==headB){
                return headA;
            }
            headA=headA.next;
            headB=headB.next;
        }
        return null;
    }

142.环形链表II

题目链接

https://leetcode.cn/problems/linked-list-cycle-ii/description/

解题思路

双指针解决问题，快慢指针， 快指针每次走俩步，慢指针每次走一步，如果有换的话，快指针比较慢指针的相对速度是1靠近慢指针一定会相遇。
满指针走半圈快指针就走了一圈，所以在满指针走一圈前一定会被追上。
公式 x 头节点到环形入口的长度 y是满指针在环里走的长度 z是 当slow和fast相遇的时候距离环形入口节点的距离
y+z等于环的长度 n就是fast转了n圈追上了slow
slow =x +y fast = x+y + n(y+z)
fast 是 slow的2倍 2(x+y)=x+y + n(y+z)
x= n(y+z) -y
x= (n-1)(y+z) + z
假设n=1 x=z 就是相遇节点到环形入口节点=头节点到环形入口节点， 这样无论n是几，转了一百圈 都是相遇节点到环形入口节点等于头节点到环形入口节点

code

//如果链表相交 链表后面的引用一定相等
    //求出链表A和链表B的长度，把长链表的指针移动到这俩个链表的差值位置比较是否相等
    //headA指针和headB指针 如果出现相等则链表相交否则不相交。
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //求出俩个链表的长度
        int a=0;
        int b=0;
        ListNode head1=headA;
        ListNode head2=headB;
        while(head1!=null){
            head1=head1.next;
            a++;
        }
        while(head2!=null){
            head2=head2.next;
            b++;
        }
        //移动长链表指针到差值位置
        int c=0;
        if(a>b){
            c=a-b;
            while(c-->0){
                headA=headA.next;
            }
        }else{
            c=b-a;
            while(c-->0){
                headB=headB.next;
            }
        }
        //比较俩个链表是否相等，相等就有交点否则没有。
        while(headA!=null&&headB!=null){
            if(headA==headB){
                return headA;
            }
            headA=headA.next;
            headB=headB.next;
        }
        return null;
    }