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

以前的博客链接：https://blog.csdn.net/weixin_43303286/article/details/131751120

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

推广到反转k个节点的链表还是不会，基础解法直接出：

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null){
            return head;
        }
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode cur = dummy;
        while(cur.next != null && cur.next.next != null){
            ListNode tmp1 = cur.next;//1
            ListNode tmp2 = cur.next.next.next;//3
            cur.next = cur.next.next;//第一步
            cur.next.next = tmp1;//第二步
            tmp1.next = tmp2;//第三步
            cur = cur.next.next;

        }
        return dummy.next;
    }
}

看图就完事了：

• 为什么移动速度是cur = cur.next.next;

你的代码中的cur = cur.next.next;是为了将当前指针cur移动到下一对需要交换的节点的前一个节点。在每次循环中，你都会交换一对节点，所以需要将cur移动两次，以便在下一次循环中处理下一对节点。

• 为什么循环条件是while(cur.next != null && cur.next.next != null)

在这段代码中，while(cur.next != null && cur.next.next != null)的作用是确保当前节点cur后面至少有两个节点，因为我们需要交换这两个节点。 因此，while(cur.next != null && cur.next.next != null)的作用是确保我们总是有两个节点可以交换，当没有足够的节点可以交换时，循环就会结束。

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

快慢指针，第一轮快的先走n步，第二轮快慢指针同步移动知道快指针移到队尾：

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode fast = dummy, slow = dummy;
        while(n > 0){
            n--;
            fast = fast.next;
        }
        while(fast.next != null){
            fast = fast.next;
            slow = slow.next;
        }
        //此时slow指针停留在要删除的节点之前
        slow.next = slow.next.next;
        return dummy.next;
    }
}

这里注意添加虚拟头节点，不然删除头节点的逻辑要单独处理。

面试题 02.07. 链表相交

思路就是先求两个链表的长度，再把两个撑起来尾部对齐，看看(len长-len短）的地方是否相同。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA, curB = headB;
        int lenA = 0, lenB = 0;
        while(curA.next != null){
            curA = curA.next;
            lenA++;
        }
        while(curB.next != null){
            curB = curB.next;
            lenB++;
        }
        //默认A是较长的链表
        if(lenA < lenB){
            //swap(lenA, lenB)
            int tmpLen = lenA;
            lenA = lenB;
            lenB = tmpLen;

            //swap(headA, headB);
            ListNode tmpNode = headA;
            headA = headB;
            headB = tmpNode;
        }
        int gap = lenA - lenB;
        curA = headA;
        curB = headB;
        while(gap > 0){
            gap--;
            curA = curA.next;
        }
        while(curB != null){
            if(curA == curB){
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;

    }
}

这里注意java没有swap的写法，需要自己创建tmp进行交换。

142.环形链表II

还是快慢指针，一个一次走两步一个一次走一步，只要有环两者必定会相交：

再让两个节点一个从入口出发，一个从相遇处出发，相等时即为入口。

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head, slow = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast){
                ListNode p1 = head;
                ListNode p2 = slow;
                while(p1 != p2){
                    p1 = p1.next;
                    p2 = p2.next;
                }
                return p1;
            }
        }
        return null;
    }
}