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

链表相关题目part2

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

两两交换链表中的节点

难点：

1. 确定是否引入虚拟头节点处理头节点的特殊情况
2. 确定交换的终止条件
3. 确定交换两个节点的处理过程

操作过程

完整代码：

public ListNode swapPairs(ListNode head) {
         if(head == null || head.next == null){
            return head;
        }
        ListNode dul = new ListNode();
        dul.next = head;
        ListNode cur = dul;
        //循环停止条件需要针对奇数个节点还是偶数个节点进行手动模拟，以确定循环条件
        while(cur.next!=null && cur.next.next!=null){
        //引入临时节点指向带交换节点的两个节点的第二个节点，以防处理前一个节点指向其他节点时，导致第二个节点丢失
            ListNode temp = cur.next;
            cur.next = cur.next.next;
            //引入临时节点指向temp.next.next，以免处理第二个节点指向前一个节点时导致后续链丢失
            ListNode temp1 = temp.next.next;
            cur.next.next = temp;
            temp.next = temp1;
            cur = temp;
        }
        return dul.next;
    }

总结：

交换操作过程中尽量操作cur节点的相关节点，如cur.next，cur.next.next，cur.next.next.next，尽量不使用临时节点指针代替
本题对于我的难点在于交换节点的处理过程

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

难点：如何进行一次遍历即可删除倒数第n个节点，由此引入双指针，以空间换时间

操作

1. 使用双指针，快指针优先走n步，
2. 然后快慢指针同时不同节点出发，此时快慢指针之间相距为n，直到快指针指向尾部节点的上一个节点为止（在本题中停止前进后，慢指针应指向被删除节点的上一个节点，因此快指针前进的终止条件：快指针指向未节点，而不是null)
3. 进行删除操作
   具体代码：

public static ListNode removeNthFromEnd(ListNode head, int n) {
        if (head == null) {
            return null;
        }
        ListNode dul = new ListNode();
        dul.next = head;
        ListNode fast = dul;
        ListNode slow = dul;
        while (n > 0) {
            fast = fast.next;
            n--;
        }
        if( fast == null){
            return head;
        }
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        if (slow.next != null) {
            slow.next = slow.next.next;
        }
        return dul.next;
    }

总结：本题对于我的难点在于，如何根据slow的位置确定最终fast的位置，已确定while的循环条件，解决此问题的最好办法就是多手动模拟

面试题 02.07. 链表相交

之前做过这个题目，所以基本的思想还是在的，但具体的操作过程很模糊，算了，不强求，直接看卡哥的解题过程，然后进行模拟：
具体代码：

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null){
            return null;
        }
        //ListNode resNode = new ListNode();
        ListNode dulA = headA;
        ListNode dulB = headB;
        int lenA = 0;
        int lenB = 0;
        //求A链表的长度
        while(dulA !=null){
            lenA ++;
            dulA = dulA.next;
        }
        //求B链表的长度
        while(dulB !=null){
            lenB ++;
            dulB = dulB.next;
        }
        while(lenB > lenA){
            //移动A,使其与B尾部对其
            dulA = dulA.next;
            lenB --;
        }
        while(lenB < lenA){
            //移动B,使其与A尾部对其
            dulB = dulB.next;
            lenA --;
        }
        //比较
        while(dulA != null){
            if(dulA == dulB){
                return dulA;
            }
            dulA = dulA.next;
            dulB = dulB.next;
        }
        return null;
    }

代码优化：如何将短链表的移动的重复代码进行合并呢？这个是我接下来得请教的问题
总结：题不难，解答过程也很容易，但就是思想要有，这还是的积累呀，见的多了，后面自然而然就熟悉了。

142.环形链表II

本题难度：难，还是要告诫自己，不要慌，十分钟过去了还是没有解决方案，就看答案
借助卡哥的解答过程模拟代码如下：

public static 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) {
                //fast和slow指向同一个元素时，此时fast或slow指向的元素到入环第节点的距离等于head到入环节点的距离
                ListNode temp = head;
                while (temp != slow) {
                    slow = slow.next;
                    temp = temp.next;
                }
                return slow;
            }

        }
        return null;
    }

告诫自己：做这类题目要运用数学和物理知识进行解答，多练，多练，多练，重要的事情说三遍

总结

通过近一周的训练营学习，自己还是存在许许多多的不足，具体如下：

1. 做题效率差
2. 卡哥视频没有进行系统的学习
3. 其他扩展题目未完全完成
   告诫自己：该看看，该练练，时间就像海绵中的水，挤一挤还是有的，加油吧，中年！！！