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

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

思路：通过画图可以看出可以通过修改指针的指向来交换节点。比如节点 1->2->3->4->5... 交换节点3和4，修改指针为 2->4, 4->3, 3->5

实现代码时，考虑几个方面：

1. 修改指针的顺序。

2. 交换节点1和2时，如何处理头节点：增加一个dummy head，避免头节点的特殊处理。

3. 奇数个节点或偶数个节点：

每次处理两个节点，如果是偶数个节点，刚好处理完；cur.next.next == null 时，停止遍历
奇数个节点，两两交换，最后会剩余一个节点，因为没有其他节点与之交换，不需要处理。当cur.next.next == null 时，停止遍历

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(-1,head);
        ListNode cur = dummy;
        while ( cur.next != null && cur.next.next != null){
            ListNode temp1 = cur.next;
            cur.next = cur.next.next;
            ListNode temp2 = cur.next.next;
            cur.next.next = temp1;
            temp1.next = temp2;
            cur = cur.next.next;
        }
        return dummy.next;
    }
}

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

思路：双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。（摘抄于：代码随想录）

代码实现：

仍然使用dummy head，避免头节点的特殊处理。

定义fast 和 slow指针，fast 指针从dummy head开始向前走N步，然后fast和slow同时向前移动，删除节点，slow指针需要停在删除节点的千一个节点，所以当fast.next == null, 停止移动

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(-1, head);
        ListNode fast = dummy;
        ListNode slow = dummy;
        for (int i = 0; i < n; i++){
            fast = fast.next;
        }
        while(fast.next != null){
            slow = slow.next;
            fast = fast.next;
        }
        slow.next = slow.next.next;
        return dummy.next;
    }
}

面试题 02.07. 链表相交

思路：和leetcode 19的思路一致。求出两个链表长度的差值，然后让较长链表的指针移动到和较短链表head对齐的位置。两个指针一起向前移动，如果通过比较，两个指针相同，则该节点是相交节点。循环退出返回空指针

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int lenA = 0;
        int lenB = 0;
        ListNode cur = headA;
        while(cur != null){
            lenA++;
            cur = cur.next;
        }
        cur = headB;
        while(cur != null){
            lenB++;
            cur = cur.next;
        }

        if(lenA < lenB){
            ListNode temp = headA;
            headA = headB;
            headB = temp;
        }
        int steps = Math.abs(lenA - lenB);
        while( steps > 0){
            headA = headA.next;
            steps--;
        }
        
        while( headA != null && headB != null) {
            if(headA == headB){
                return headA;
            }else{
                headA = headA.next;
                headB = headB.next;
            }
        }
        return null;
        
    }

LeetCode142.环形链表II

这道题需要解决两个问题：

1、判断是否有环。可以通过快慢指针判断，如果快慢指针相遇，则有环。如果快指针到达null，说明没有环。

2.如何找到环形入口。解决这个问题需要简单的代数计算。从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是环形入口的节点。（代码随想录）

public class Solution {
    public ListNode detectCycle(ListNode head) {
        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 slow;
            }
        }
        return null;
    }
}

总结：

一般涉及到增删改操作，用虚拟头结点都会方便很多，如果只能查的话，用不用虚拟头结点都差不多。