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

目录

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

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

面试题 02.07. 链表相交

142.环形链表II

---

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

用虚拟头结点，这样会方便很多。

本题链表操作就比较复杂了，建议大家先看视频，视频里我讲解了注意事项，为什么需要temp保存临时节点。

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

题解思路：

这里我觉得卡哥视频已经讲的很透彻了对于原理的说明，其大致的过程可以看下图所画的结构分析

但还有以下几点需要值得注意：
1、交换节点使用虚拟头节点的时候，需要先声明一个虚拟头节点的对象，将虚拟节点的next域指向链表中真实的头节点
2、while的循环条件是&&的关系，不是||的关系，具体见注释说明
3、移动到的进行操作的节点一定是：对链表中进行交换两个节点前的那个节点操作，才能顺顺利利的完成交换的动作

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyNode = new ListNode(); //声明一个虚拟头节点的对象
        dummyNode.next = head; //将虚拟节点的next域指向链表中真实的头节点
        ListNode current = dummyNode; 
        while(current.next != null && current.next.next != null){ 
        //偶数个节点循环遍历的终止条件：current.next = null；奇数个节点循环遍历的终止条件：current.next.next = null
        //当有偶数个节点时满足循环遍历的终止条件时，同时也满足current.next.next = null这个条件；当有奇数个节点满足循环遍历终止的条件时，此时current.next != null，如果while循环条件内两个条件是或的关系时，在奇数个节点时，此时会进入循环体，很明显的一个空指针异常会报错在移动的下一个位置是空指针异常，所以此时的while循环条件一定是 && 的关系
            ListNode temp = current.next; //交换前进行临时变量的保存，否则会直接与相关节点的联系的
            ListNode temp1 = current.next.next.next;

            current.next = current.next.next; 
            current.next.next = temp;
            temp.next = temp1; //两两节点进行交换

            current = current.next.next; //移动到交换下一个进行链表中两个节点交换位置的前一个节点的位置处
        }
        return dummyNode.next;
    }
}

---

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

双指针的操作，要注意，删除第N个节点，那么我们当前遍历的指针一定要指向 第N个节点的前一个节点，建议先看视频。

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

题解思路：

这里卡哥视频讲的也很清楚，使用虚拟头节点为了让头节点和其他节点具有一样的待遇，使得操作头节点和操作其他节点一样，平等对待头节点和其他节点，只要将其视为链表中的第0个元素，这样也不会造成实际链表中个数的改变，一切照旧，还方便操作头节点，不需要考虑是不是头节点的问题，然后使用不同的方法去题解，会简单很多！！！
好！言归正转，这题主要分三步去实现，具体每一步为什么是这么操作，在注释说的很明白：
1、fast指针先移动n+1步，使其fast和slow指针错位n+1个位置；
2、同时移动fast和slow指针；
3、删除节点的操作；
如果原理上还没理解的很透，非常建议大家移步到卡哥视频去听讲解，YYDS！！！

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyNode = new ListNode();
        dummyNode.next = head;
        ListNode fast = dummyNode;
        ListNode slow = dummyNode;

        //第一步：选让fast指针移动n + 1步，第二步：然后在移动fast指针一直到链表尾部，同时在第二步移动的过程中要同时移动slow指针，可以这么去理解fast指针的作用，因为删除的是倒数第n个节点，那么fast和slow之间错位的这n步就是为了，当fast移动到链表结尾时，那么slow指针指向的就是以fast指针为参考起点的第n位置处的节点，但是（正常视角从头节点开始正着数看）删除第n个节点位置，需要对第n - 1个节点进行操作，所以fast指针和slow之间必须要错位n+1步，才能找到对删除倒数第n个节点操作的第n-1位置处的节点
        //1、fast指针先移动n+1步，使其fast和slow指针错位n+1个位置
        n++;
        while(n > 0 && fast != null){ //这里fast != null，是因为如果n超过了链表的长度size = 头节点（第0个节点） + 节点1 + 节点2 + 节点3 ...，,那么如果没有这个条件就会报空指针的异常，所以这个条件限制了fast只能移动到最后节点的位置，这里一定先看卡哥视频，图解的很详细，很容易看出来循环终止的判断条件
            fast = fast.next;
            n--;
        }

        //2、同时移动fast和slow指针
        while( fast != null){
            fast = fast.next;
            slow = slow.next;
        }

        //3、删除节点的操作
        slow.next = slow.next.next;
        return dummyNode.next;

    }
}

---

面试题 02.07. 链表相交

本题没有视频讲解，大家注意 数值相同，不代表指针相同。

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

题解思路：

看着题解算是能写出代码，主要分解为以下几个部分去实现：
第一：分别计算出每个节点的数量，并计算差值
第二：移动长的链表中的指针到与短的链表的指针齐头并进的位置，使其两个指针的末尾对齐
第三：此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode currentA = headA;
        ListNode currentB = headB;

        //1、头节点是headA的链表中节点的个数
        int countA = countLink(headA);
        //2、头节点是headB的链表中节点的个数
        int countB = countLink(headB);

        //3、两个链表中节点个数差值
        int lengthDifference = (countA - countB > 0)? (countA - countB):(countB - countA);

        //4、移动长的链表中的指针到与短的链表的指针齐头并进的位置，使其两个指针的末尾对齐
        if(countA > countB){
            //移动长的链表中的指针
            while(lengthDifference > 0 ){
                currentA = currentA.next;
                lengthDifference--;
            }
        }else{
            while(lengthDifference > 0 ){
                currentB = currentB.next;
                lengthDifference--;
            }
        }

        //5、此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。
        while(currentA != null && currentB != null ){ // 由于currentA和currentB长度是相同的了，因此只需要判断一个不为空指针就可以了
            if(currentA == currentB){
                return currentA;
            }
            currentA = currentA.next;
            currentB = currentB.next;
        }

        return null;
    
    }

    //定义方法：计算头节点是head的链表中节点的个数
    public int countLink(ListNode head){
        int count = 0;
        ListNode current = head;
        while(current != null){ //这里不能是current.next ！= null，因为链表的长度包含头节点，只不过是当作第0个节点而已
            current = current.next;
            count++;
        }
        return count;
    }

}

---

142.环形链表II

算是链表比较有难度的题目，需要多花点时间理解 确定环和找环入口，建议先看视频。、

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

题解思路：

使用快慢指针的方法寻找环形链表的入口处其实这里卡哥视频的原理讲的很透彻，主要有两大块内容去解决：
第一块：首先判断是否能找到快慢指针相遇处的那个节点从而判断是否是个环形链表。这里的快慢指针以相对步长为1，此时如果是个环形链表则一定会相遇的，不会发生跳过慢指针而找不到相遇的节点，因为相对步长为1，那么如果是环行链表，意味着快指针是以每次移动一步的速度去逼近慢指针，不会跳过慢指针的；如果都没有相遇，说明一定不是环形链表。
第二步：在找到快慢指针相遇的节点的情况下，此时一定是个环形链表，那么在重新定义两个指针，从头节点和在环内相遇的节点处开始一步一步去移动，这里已经判断是环形链表了，那么这两个指针一定会相遇的，这里的原理也可以去看卡哥视频，说的很详细，可以把环平铺开来就能分析一定会相遇，而且由于快指针走的路程是慢指针的两倍，因此慢指针一定是在第一圈就被快指针去追上的，至于为什么相遇的点就是环的入口卡哥的视频有推导公式也说的很清楚，文字版叙述不出来了，可以先只记下结论去用就好好！！！

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        //1、先找到快慢指针相遇的节点，如果找到说明是个环形链表，如果没有找到，说明不是环形链表；
        //其中快指针以步长为2去移动，慢指针以步长为1去移动，此时快慢指针以相对为1的步长去不断的逼近，因此不会遇到跳过慢指针没遇到的情况，如果实在没遇到，那一定不是环形链表
        while(fast != null && fast.next != null){ //因为快指针是以步长为2移动，因此需要判断fast和fast.next都不为空指针才能执行循环体，否则循环体内就会报空指针异常了，因为快指针走在慢指针前面，因此快指针遇到null，那慢指针也不会移动到空指针的地方，所以while终止条件不必判断慢指针为空指针的条件了

            fast = fast.next.next; 
            slow = slow.next; 

            if(fast == slow){
                //进入这个这个if条件内，说明fast指针与slow指针已经相遇到了
                ListNode index1 = fast; // 这里保存相遇的节点，好让另一个index2节点从头节点开始以相同的步长去移动，直到遇到时的节点就是环的入口节点
                ListNode index2 = head; //想要找到环的入口点，此时index1节点与index2节点都是每次移动一步，直到相遇就是入口的节点
                while(index1 != index2){  //如果index1与index2不想等，则进行循环体内一直去移动即可
                    index1 = index1.next;
                    index2 = index2.next;
                } //出了循环体说明已经找到了环的入口处，此时在返回index1或者index2即可
            return index1;
            }
        }
        return null;
    }
}