代码随想录算法训练营day4 24. 两两交换链表中的节点 ，19.删除链表的倒数第N个节点 ，面试题 02.07. 链表相交 ，142.环形链表II

day会在明天休息日更新一下，昨天有点小事情，okok开始今天的题目。

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

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

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;
        while(cur->next != nullptr && cur->next->next != nullptr) {
            ListNode* tmp = cur->next; // 记录临时节点
            ListNode* tmp1 = cur->next->next->next; // 记录临时节点

            cur->next = cur->next->next;    // 步骤一
            cur->next->next = tmp;          // 步骤二
            cur->next->next->next = tmp1;   // 步骤三

            cur = cur->next->next; // cur移动两位，准备下一轮交换
        }
        return dummyHead->next;
    }
};

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

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

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

    return dummyhead->next;

    }
};

面试题 02.07. 链表相交

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

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

示例 2：

示例 3：

class Solution {
	public:
		ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
			ListNode* curA = headA;
			ListNode* curB = headB;
			int lenA = 0, lenB = 0;
			while (curA != NULL)
			{
				lenA += 1;
				curA = curA->next;
			}
			while (curB != NULL)
			{
				lenB += 1;
				curB = curB->next;
			}
			curA = headA;
			curB = headB;
			if (lenB > lenA)
			{
				swap(lenB, lenA);
				swap(curB, curA);
			}
			int gap = lenA - lenB;
			while (gap--)
			{
				curA = curA->next;
			}
			while (curA != NULL)
			{
				if (curA == curB)
				{
					return curA;
				}
				curA = curA->next;
				curB = curB->next;
			}
			return NULL;
		}
	};

 142.环形链表II 

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

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast = head,*slow = head;
        while(fast != nullptr && fast->next != nullptr){
            slow = slow->next;
            fast = fast->next->next;
            //相遇
            if(fast == slow){
                ListNode *index1 = fast;
                ListNode *index2 = head;

                while(index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;

        
    }
};