代码随想录算法训练营43期 | Day 4——24.交换链表、19.删除链表第N个节点、

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

解题思路

1. 设置dummyHead节点并且dumyHead->next = head;
2. 设置cur指向dummyHead；
3. 步骤一：
   使用temp保存cur->next节点和temp1保存cur->next->next->next;
   令cur->next = cur->next->next;
4. 步骤二：
   cur->next->next = temp;
5. 步骤三：
   cur->next->next->next = temp1;
6. cur移动两步 cur = cur->next->next;

ListNode* swapPairs(ListNode* head) {
        //定义虚拟头结点
        ListNode* dummyHead  = new ListNode(0);
        dummyHead->next = head;
        ListNode* cur = dummyHead;
        while(cur->next!=nullptr&&cur->next->next!=nullptr)
        {
            //临时保存cur->next 
            ListNode* temp = cur->next;
            ListNode* temp1 = cur->next->next->next;
            //步骤1 
            cur->next = cur->next->next;
            //步骤2 
            cur->next->next = temp;
            //步骤3
            cur->next->next->next = temp1;

            //移动cur指针
            cur = cur->next->next;
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }

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

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

解题思路

1. 计算得到链表长度 len；
2. 使用dummyhead虚拟头节点
3. 删除导数第n个节点，需要遍历 len - n

 ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* node = head;
        int len = 0;
        while(node)
        {
            node = node->next;
            len++;
        }
        int count = len-n;
        ListNode* dummyhead = new ListNode(0);
        dummyhead->next = head;
        ListNode* cur = dummyhead;
        for(int i = 0; i < count; i++ )
        {
            cur = cur->next;
        }
        cur->next = cur->next->next;
        ListNode* ans = dummyhead->next;
        delete dummyhead;
        return ans;

    }

双指针法：
定义快慢指针，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。
定义dummyHead，fast 和 slow 指针指向dummyHead

 ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead;

        while(n--&&fast!=nullptr)
        {
            fast = fast->next;
        }

        //当fast指向链表末尾时,slow指向的是删除元素的前一个元素,fast 和  slow之间 有一个元素
        while(fast->next!=nullptr)
        {
            fast = fast->next;
            slow = slow->next;
        }
        //删除元素
        ListNode* temp = slow->next; 
        slow->next = temp->next;
        delete temp;
        return dummyHead->next;
    }

面试题 02.07. 链表相交

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：

解题思路

哈希表：
判断两个链表是否相交，可以使用哈希集合存储链表节点；

1. 首先遍历链表 headA，并将链表 headA 中的每个节点加入哈希集合中。
2. 然后遍历链表 headB，对于遍历到的每个节点，判断该节点是否在哈希集合中
3. 如果当前节点不在哈希集合中，则继续遍历下一个节点；
4. 如果当前节点在哈希集合中，则后面的节点都在哈希集合中，即从当前节点开始的所有节点都在两个链表的相交部分，因此在链表 headB 中遍历到的第一个在哈希集合中的节点就是两个链表相交的节点，返回该节点。

 ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        //利用哈希表来实现
        unordered_set<ListNode* > visited; 
        ListNode* temp = headA;
        while(temp!=nullptr)
        {
            visited.insert(temp);
            temp = temp->next;
        }
        temp = headB;
        while(temp!=nullptr)
        {
            if(visited.count(temp))
            {
                return temp;
            }
            temp = temp->next;
        }
        return nullptr;
    }

142.环形链表II

题意： 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

• 判断是否有环
• 如果有环，如何找到环的入口

如何判断是否有环？
可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。
首先第一点：fast指针一定先进入环中，如果fast指针和slow指针相遇的话，一定是在环中相遇，这是毋庸置疑的。

如何找到环的入口？
假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。 如图所示：

slow指针走过的节点数为: x + y，fast指针走过的节点数：x + y + n (y + z)，为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A，(x + y) * 2 = x + y + n (y + z），两边消掉一个（x+y）: x + y = n (y + z)，因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。所以要求x ，将x单独放在左面：x = n (y + z) - y，
再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针
这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点

  ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }