代码随想录 打卡4

两两交换链表中的节点 删除链表的倒数第N个节点 链表相交 环形链表II

---

两两交换链表中的节点

• 添加个虚拟头节点
• 画图
  • core:
  • pCur->pNext = pCur->pNext->pNext;
  • pCur->pNext->pNext = p1;
  • pCur->pNext->pNext->pNext = p2;

ListNode* swapPairs(ListNode* pHead) 
{
    if (pHead == nullptr) return nullptr;

    ListNode* pDummy = new ListNode(-1);
    pDummy->pNext = pHead;
    ListNode* pCur = pDummy;
    while(pCur->pNext != nullptr && pCur->pNext->pNext != nullptr)
    {
        ListNode* p1 = pCur->pNext;
        ListNode* p2 = pCur->pNext->pNext->pNext;
        
        pCur->pNext = pCur->pNext->pNext;
        pCur->pNext->pNext = p1;
        pCur->pNext->pNext->pNext = p2;

        pCur = pCur->pNext->pNext;
    }
    return pDummy->pNext;
}

移除元素

int removeEle(vector<int> vec, int val)
{
    auto S = 0;
    for (auto F = 0; F < vec.size(); F++)
    {
        if (vec[F] != val)
            vec[S++] = vec[F];
    }
    return S;
}

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

ListNode* removeNthFromEnd(ListNode* pHead, int n) 
{
    if (pHead == nullptr) return nullptr;

    ListNode* pDummy = new ListNode(-1);
    pDummy->pNext = pHead;

    ListNode* pFast = pDummy;
    ListNode* pSlow = pDummy;
    while(n-- && pFast != nullptr)
    {
        pFast = pFast->pNext;
    }
    pFast = pFast->pNext;
    while(pFast != nullptr)
    {
        pFast = pFast->pNext;
        pSlow = pSlow->pNext;
    }
    ListNode* pDel = pSlow->pNext;
    pSlow->pNext = pSlow->pNext->pNext;
    delete pDel;
    return pDummy->pNext;
}

链表相交

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
{
    ListNode* pA = headA;
    ListNode* pB = headB;
    int nLenA = 0;
    int nLenB = 0;
    // Calc Length
    while(pA != nullptr)
    {
        nLenA++;
        pA = pA->pNext;
    }
    while(pB != nullptr)
    {
        nLenB++;
        pB = pB->pNext;
    }
    pA = headA;
    pB = headB;

    if (nLenB > nLenA)
    {
        swap(nLenA, nLenB);
        swap(pA, pB);
    }

    int gap = nLenA - nLenB;
    while(gap--)
    {
        pA = pA->pNext;
    }
    while(pA != nullptr)
    {
        if (pA == pB)
            return pA;
        pA = pA->pNext;
        pB = pB->pNext;
    }
    return nullptr;
}

环形链表II

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;
    }