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

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

动手画画图理清顺序即可

ListNode* swapPairs(ListNode* head) {
    //不够交换则直接结束
    if (head == nullptr || head->next == nullptr) return head;

    ListNode* dummyNode = new ListNode(0, head);
    ListNode* p = dummyNode;
    while (p->next != nullptr && p->next->next != nullptr)
    {
        ListNode* tmp = p->next;
        p->next = tmp->next;
        tmp->next = tmp->next->next;
        p->next->next = tmp;

        p = p->next->next;
    }

    return dummyNode->next;
}

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

1.常规方法（遍历两次）

ListNode* removeNthFromEnd(ListNode* head, int n) {
    //简单方法就是直接遍历到尾，这样就可以知道长度
    ListNode* dummyNode = new ListNode(0, head);
    ListNode* p = head;
    int cnt = 0;
    while (p != nullptr) 
    {
        p = p->next;
        cnt++;
    }

    p = dummyNode;
    cnt -= n;
    while (cnt--) p = p->next;

    ListNode* tmp = p->next;
    p->next = tmp->next;
    delete tmp;

    return dummyNode->next;
}

2.进阶（遍历一次）

ListNode* removeNthFromEnd(ListNode* head, int n) {
    //快慢指针，快先n，随后一起走，快到尾部则慢到目标
    ListNode* dummyNode = new ListNode(0, head);
    ListNode* fast = dummyNode;
    ListNode* slow = dummyNode;

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

    ListNode* tmp = slow->next;
    slow->next = tmp->next;
    delete tmp;

    return dummyNode->next;
}

面试题 02.07. 链表相交

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    //统计两个链表的长度，据此对齐二者
    ListNode* p = headA;
    ListNode* q = headB;
    int cntA = 0;
    int cntB = 0;
    while (p != nullptr) 
    {
        p = p->next;
        cntA++;
    }
    while (q != nullptr)
    {
        q = q->next;
        cntB++;
    }

    if (cntB > cntA) 
    {
        p = headB;
        q = headA;
    }
    else
    {
        p = headA;
        q = headB;
    }
    int cnt = abs(cntA - cntB);


    while (cnt--)
    {
        p = p->next;
    }

    while (p != nullptr && q != nullptr)
    {
        if (p == q) return p;
        p = p->next;
        q = q->next;
    }

    return nullptr;
}

142. 环形链表 II

这道题的难点在于怎么找到入口处，这个找到的方法需要一定数学推导，比较巧妙

可以多次联系

ListNode *detectCycle(ListNode *head) {
    ListNode* dummyNode = new ListNode(0, head);
    //可以快慢指针，快走2，慢走1
    ListNode* fast = dummyNode;
    ListNode* slow = dummyNode;


    while (fast != nullptr && fast->next != nullptr)
    {
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow) 
        {
            ListNode* a = dummyNode;
            ListNode* b = slow;
            while (a != b)
            {
                a = a->next;
                b = b->next;
            }
            return a;
        }
    }
    return nullptr;
}