算法学习笔记 4 | 24. 两两交换链表中的节点、19. 删除链表的倒数第N个节点、142. 环形链表II | 代码随想录

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

题目链接：24. 两两交换链表中的节点
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

思路：
最好是画一个图来梳理交换链表节点的思路。

以上图逻辑，首先设置虚拟头节点，并指向链表。再设置两个临时节点temp1和temp2，然后执行交换操作。
时间复杂度：O(n)
空间复杂度：O(1)

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyhead = new ListNode(0, head);
        ListNode* cur = dummyhead;
        while (cur->next!=nullptr && cur->next->next!=nullptr)
        {
            ListNode* temp1 = cur->next;
            ListNode* temp2 = cur->next->next->next;
            cur->next = cur->next->next;
            cur = cur->next;
            cur->next = temp1;
            temp1->next = temp2;
            cur = cur->next;
        }
        return dummyhead->next;
    }
};

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

题目链接：19. 删除链表的倒数第N个节点
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

思路：
一般思路是遍历两遍链表，第一遍得到链表长度size，由此得到倒数第N个节点即为第size-N个节点。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int size = 0;
        int index;
        ListNode* dummyhead = new ListNode(0,head);
        ListNode* cur = dummyhead;
        while (cur->next!=nullptr)
        {
            cur = cur->next;
            size++;
        }
        index = size - n;
        cur = dummyhead;
        for (int i = 0;i<index;i++)
        {
            cur = cur->next;
        }
        if (cur->next!=nullptr)
        {
            ListNode* temp = cur->next;
            cur->next = cur->next->next;
            delete temp;
        }
        
        return dummyhead->next;
    }
};

但是利用双指针思想可以只用遍历一遍。
让快指针保持在慢指针后N个节点，每次循环同时移动快慢指针，这样当快指针挪动到尾节点后一个时，慢指针指向的则是需要删除的节点。所以将快指针挪动到尾节点，然后删除慢指针后面的那个节点即可。
时间复杂度: O(n)
空间复杂度: O(1)

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead = new ListNode(0,head);
        ListNode* fast = dummyhead;
        ListNode* slow = dummyhead;
        for (int i =0; i<n;i++)
        {
            fast  = fast->next;
        }
        while (fast->next!=nullptr)
        {
            fast = fast->next;
            slow = slow->next;
        }
        if (slow ->next != nullptr)
        {
            ListNode* temp = slow->next;
            slow->next = slow->next->next;
            delete temp;
        }
        return dummyhead->next;
    }
};

142.环形链表II

题目链接：142. 环形链表II
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改链表

思路：

首先判断是否有环

可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环（当慢指针进入环中后，相当于快指针在每次多移一个节点去追赶慢指针）。

得到环的入口

由数学公式可以判断出，从头节点和环内相遇节点同时出发一个指针，两指针相遇的地方即为环的入口节点。（数学原理较复杂，参考代码随想录视频：环形链表-代码随想录

时间复杂度: O(n)，快慢指针相遇前，指针走的次数小于链表长度，快慢指针相遇后，两个index指针走的次数也小于链表长度，总体为走的次数小于 2n
空间复杂度: O(1)

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