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

本文链接：https://blog.csdn.net/Cautial/article/details/133245148

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

思路：

首先设置一个虚拟头节点，方便处理实际链表的头节点。然后设置三个指针，其中两个指针用于交换，第三个指针用于记录下一个要进行交换的位置，没记录的话下一个交换的位置就会丢失。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* cur = dummyHead;

        while (cur->next != NULL && cur->next->next != NULL) {
            ListNode* tmp1 = cur->next;
            ListNode* tmp2 = cur->next->next->next;

            cur->next = cur->next->next;
            cur->next->next = tmp1;
            tmp1->next = tmp2;

            cur = cur->next->next;
        }

        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

时间复杂度：O(n)

空间复杂度：O(1)

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

题目链接：Leetcode19. 删除链表的倒数第N个节点

文章讲解：代码随想录—19. 删除链表的倒数第N个节点

思路：

刚开始想是否可以直接走到删除点的前一节点，但因为并不知道链表有多长，所以没有办法让他提前走到删除点前一位。

文章的解法就巧妙的运用了双指针，刚开始快慢指针都指向虚拟头部，然后让快指针先走 n+1 步，走 n+1 步是想让慢指针定位在删除节点的前一节点。

这里为什么可以使用双指针呢？个人认为如果不用双指针，就要先遍历一遍得出链表长度，然后才能把指针定位到删除节点。因此，在这里，也是想利用双指针使两边循环变为一遍循环，和之前的思路是一样的。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while (n -- && fast != NULL) fast = fast->next;
        fast = fast->next;
        while (fast != NULL) {
            slow = slow->next;
            fast = fast->next;
        }
        ListNode* tmp = slow->next;
        slow->next = tmp->next;
        delete tmp;
        return dummyHead->next;
    }
};

时间复杂度：O(n)

空间复杂度：O(1)

遇到的问题：不能 return head，因为没有考虑到删除头结点的情况。可以让 head = dummyHead->next; return head

面试题 02.07. 链表相交

题目连接：Leetcode面试题 02.07. 链表相交

文章讲解：代码随想录—面试题 02. 07. 链表相交

思路：

看了解析感觉题意表达不明确，有没有交代说只有链表末尾才相交，这个题太有歧义了...

姑且按着题解的理解来，只能在末尾相交的话就把指针指到短链表的头，另一个也移动到和前一指针对齐，两指针一起向后遍历看是否重合。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int a = 0, b = 0;
        while (curA != NULL) {
            a ++;
            curA = curA->next;
        }
        while (curB != NULL) {
            b ++;
            curB = curB->next;
        }
        int len = a > b ? (a - b) : (b - a);
        curA = a > b ? headA : headB;
        curB = a > b ? headB : headA;
        while (len --) curA = curA->next;
        while (curA != curB) {
            curA = curA->next;
            curB = curB->next;
        }
        if (curA == NULL) return NULL;
        return curA;
    }
};

时间复杂度：O(n+m)

空间复杂度：O(1)

142. 环形链表 II

题目链接：Leetcode142. 环形链表 II

文章讲解：代码随想录—142. 环形链表 II

思路：

这个题第二遍做，数学思维很强，想解释清楚比较困难

首先双指针设置快慢双指针，慢指针一次走一步，快指针一次走两步，目的是确认是否有环，如果有环快慢指针一定能相遇。

找到相遇点后，如下图，再找一个指针从头出发，快指针从相遇点出发，直到这两个指针相遇，相遇点就是环的起始节点。

即便快指针走了很多圈才和慢指针相遇，找环入口的方法也是一样的

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* slow = head;
        ListNode* fast = head;
        while (fast != NULL && fast->next != NULL) {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) {
                ListNode* cur = head;
                while (cur->val != fast->val) {
                    cur = cur->next;
                    fast = fast->next;
                }
                return cur;
            }
        }
        return NULL;
    }
};

时间复杂度：O(n)

空间复杂度：O(1)