代码随想录算法训练营第四天

文档讲解：代码随想录 (programmercarl.com)
视频讲解：帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点_哔哩哔哩_bilibili
状态：

24. 两两交换链表中的节点 - 力扣（LeetCode） 
 

/**
 * 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; }
 * }
 */
// 自己写的
// 时间复杂度O(n)
// 空间复杂度O(1)
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        ListNode temp = null;
        head = head.next;
        while(slow != null && slow.next != null) {
            fast = slow.next;
            if(temp != null)temp.next = fast;
            temp = fast.next;
            fast.next = slow;
            slow.next = temp;
            temp = slow;
            slow = slow.next;
        }
        return head;
    }
}

// 虚拟头节点
// 时间复杂度O(n)
// 空间复杂度O(1)
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyhead = new ListNode();
        dummyhead.next = head;
        ListNode temp = dummyhead;    // 0号节点(虚拟节点)
        ListNode cur = head;          // 1号节点
        while(cur != null && cur.next != null) {
            // 0号节点指向2号节点
            temp.next = cur.next;

            temp = cur.next;
            cur.next = cur.next.next;  // 1号节点指向3号节点
            temp.next = cur;           // 2号节点指向1号节点
            
            temp = cur;            
            cur = cur.next;
        }
        return dummyhead.next;
    }
}

// 递归
// 时间复杂度O(n)
// 空间复杂度O(n)

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null)return head;
        ListNode next = head.next;
        ListNode newNode = swapPairs(next.next);
        next.next = head;
        head.next = newNode;
        return next;
    }
}

19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）
 

// 暴力解法
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        int num = 0;
        ListNode dummyhead = new ListNode();
        dummyhead.next = head;
        ListNode cur = head;
        while(cur != null) {
            num++;
            cur = cur.next;
        }
        cur = dummyhead;
        int loop = num - n;
        while(loop > 0) {
            cur = cur.next;
            loop--;
        }
        if(num < n || n <= 0)return head;
        if(cur.next == null)return head;
        cur.next = cur.next.next;
        return dummyhead.next;
    }
}

// 虚拟头节点 + 双指针
// 时间复杂度O(n)
// 空间复杂度O(1)
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyhead = new ListNode();
        dummyhead.next = head;
        ListNode fast = dummyhead;
        ListNode slow = dummyhead;
        for(int i = 0; i < n; i++) {
            fast = fast.next;
        }
        while(fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return dummyhead.next;
    }
}

面试题 02.07. 链表相交 - 力扣（LeetCode）
这道题目我其实觉得我的思路更好，时间复杂度应该刚好是O(n)
思路：

• curA遍历headA链表后遍历headB链表
• curB遍历headB链表后遍历headA链表
• curA和curB在同一个循环里进行遍历
• 如果headA链表与headB链表相交，则它们一定会在某一点相等！

代码如下：
 

// 时间复杂度O(n)
// 空间复杂度O(1)
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode one = headA;
        ListNode another = headB;
        boolean flag1 = true;
        boolean flag2 = true;
        while(one != null && another != null && one != another) {
            one = one.next;
            another = another.next;
            if(one == null && flag1) {
                one = headB;
                flag1 = false;
            }
            if(another == null && flag2) {
                another = headA;
                flag2 = false;
            }
        }
        if(one == another) return one;
        return null;
    }
}

// 代码随想录中的解法
// 时间复杂度O(n + m)
// 空间复杂度O(1)
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int len1 = 0;
        int len2 = 0;
        while(curA != null) {
            curA = curA.next;
            len1++;
        }
        while(curB != null) {
            curB = curB.next;
            len2++;
        }
        curA = headA;
        curB = headB;
        if(len1 > len2) {
            int loop = len1 - len2;
            while(loop > 0) {
                curA = curA.next;
                loop--;
            }
        } else {
            int loop = len2 - len1;
            while(loop > 0) {
                curB = curB.next;
                loop--;
            }
        }
        while(curA != null) {
            if(curA == curB)return curA;
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}

142. 环形链表 II - 力扣（LeetCode）

环形链表如图所示

首先确认问题分为两个部分：

1. 如何判断是否有环？
2. 环的起点在哪里？

如何判断有环
快慢指针法：快指针走两步，慢指针走一步，若能够快指针最终能和慢指针指向同一个节点，则有环。
为什么可以用快慢指针法
当慢指针进入环时，快指针已经在环中，但无论在环中哪个位置，快指针都可以追上慢指针，因为快指针相对于慢指针会多走一步，这能够确保快指针不会越过慢指针。

如何确认环的起点

meet节点是快慢指针相遇的节点
快指针走的路程是：x + y + n * (y + z)   【n表示走的圈数】
慢指针走的路程是：x + y
快指针每次走两步，慢指针每次走一步，故快指针路程是慢指针的两倍
2 * (x + y) = x + y + n * (y + z)
因为我们最终要求的是x，即起点距离头节点的距离
x = (n - 1)(y +  z) + z
因为y + z是环一圈的长度，所以我们可以发现，如果一个指针从meet点出发，一个指针从头节点出发，最终一定会在起点处相遇。

为什么慢指针不会绕环一圈
如果慢指针绕环一圈，则快指针一定绕环两圈，而快指针在这个过程中一定已经追上了慢指针，故慢指针不会绕环一圈。

代码如下：
 

// 时间复杂度O(n)
// 空间复杂度O(1)
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) {
                ListNode meet = fast;
                ListNode start = head;
                while(meet != start) {
                    meet = meet.next;
                    start = start.next;
                }
                return meet;
            }
        }
        return null;
    }
}

链表其实相对来将操作更复杂一点，虚拟头节点是一个很好的方法。环形链表这个问题还是比较困难的。