代码随想录训练营Day4 Leetcode24、19、142 草稿纸上绘图间，链表之美尽显真。

Leetcode24

题目描述：

从前到后，两个两个相邻节点进行交换，每个节点只允许交换一次，没有与之匹配的节点不需要交换。1-2-3-4-5   交换完  2-1-4-3-5

思路解析：

对于单链表，交换两个节点需要站在第一个节点的前一个节点进行操作，因此，由于头节点没有前一个节点，所以我们使用虚拟头节点进行操作。pqt三个指针，初始化为 p：虚拟头节点，q：头节点，t：q的下一个节点。遍历链表完成交换。

代码及注释详解：

ListNode* swapPairs(ListNode* head) {
    //链表节点数小于2
    if (!head || !head->next) {
        return head;
    }

    //创建虚拟头节点，有利于对链表进行操作
    ListNode nullHead;
    ListNode* p = &nullHead;
    p->next = head;

    // 虚拟头节点-1-2-3-4-5-nullptr
    //第一步是交换1、2 我们需要站在1、2的前面即虚拟头节点的位置
    ListNode* q = head;
    ListNode* t = q->next;

    //temp用来存储当前交换节点的下一个节点
    ListNode* temp;
    while (q && t) {
        //存储下一次的开头
        temp = t->next;

        //交换
        p->next = t;
        q->next = t->next;
        t->next = q;

        //如果后面都不存在两个及以上节点，直接跳出，交换结束
        if (!q->next || !q->next->next)break;

        //为下一次交换做准备
        p = q;
        q = q->next;
        t = q->next;
    }
    return nullHead.next;
}

Leetcode19

题目描述：

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

思路解析：

虚拟头节点确实很好用，避免对链表边界情况的特殊考虑。

先让一个节点p，从虚拟头节点出发走n+1步，实际上就是从head出发走到第n个节点，然后在创建一个指针q在虚拟头节点的位置，pq同时向后移动，直到p为nullptr，结束循环，q即为倒数第n个节点的前一个节点。代码有详细解析和举例。

代码及注释详解：

ListNode* removeNthFromEnd(ListNode* head, int n) {
    
    ListNode nullHead;
    ListNode* p = &nullHead;
    p->next = head;

    //指针p走到第n个节点
    int i = 1;
    for (; p && i <= n + 1; i++) {
        p = p->next;
    }
    //如果节点数小于n，那肯定不存在倒数第n个，直接点返回
    if (i != n + 2)return head;

    //指针q指向当前倒数第n个节点的前一个结点
    ListNode* q = &nullHead;

    //循环直到p等于nullptr
    while (p) {
        p = p->next;
        q = q->next;
    }

    //q即为倒数第n个节点的前一个结点
    q->next = q->next->next;
    return nullHead.next;

    //举个例子 假设-1代表虚拟头节点
    //原链表 1-2-3-4-5-null 删除倒数第2个节点
    //现链表 -1-1-2-3-4-5-null
    //        p-----p    p会从-1走3步走到3节点
    //        q     p    pq同时向后移动直到p为null
    //              q     p
    //q此时就是倒数第2个节点的前一个结点

}

Leetcode160

题目描述：

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

思路解析：

题目进阶版时间复杂度为O(m+n)，我们使用进阶版做法，使用unordered_set，为什么不用set因为没必要有序，题目不需要。1.先遍历一遍链表A，将A的节点存储至容器，在依次遍历链表B，对于遍历B的每个节点做判断是否存在于unordered_set里面，若存在即为相交节点。

代码及注释详解：

ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
    unordered_set<ListNode*>uset;

    //将链表A的每个节点存储至uset
    ListNode* temp = headA;
    while (temp) {
        uset.insert(temp);
        temp = temp->next;
    }

    //遍历B判断是否存在相交节点
    temp = headB;
    while (temp) {
        if (uset.count(temp)) {
            return temp;
        }
        temp = temp->next;
    }
    return nullptr;
}

Leetcode142

题目描述：

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

思路解析：

注意注意！！！一定要画图！！！你会发现很简单！！！

画图！！！

1.快慢指针依次从头节点出发，fast一次走两步，slow一次走一步。直到相交，记录相交位置

2.在拿一个指针从头节点出发，另一个指针从相交位置出发，两个人同时走，都是一次走一步。

3.你会发现，相遇即相交，即为环的第一个节点，为什么呢？画图！！！

4.有点抽象，忘记带纸笔了，自己一定要花一遍，设周长为x！！！

代码及注释详解

ListNode* detectCycle(ListNode* head) {
    if (!head || !head->next)return nullptr;

    //设置快慢指针
    ListNode* fast = head;
    ListNode* slow = head;
    
    //找到相交节点
    while (fast && fast->next) {
        fast = fast->next->next;
        slow = slow->next;

        if (fast == slow)break;
    }
    //不存在环则返回null
    if (!fast || !fast->next)return nullptr;

    //设置一个指针从头节点出发
    slow = head;

    //同时同速度走
    while (slow != fast) {
        slow = slow->next;
        fast = fast->next;
    }

    
    return fast;


}