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

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

个人感觉这个不太难，刚开始打算用步进值为2，来搞，但是没有想到链表应该是怎么样的，
原来可以直接用：

 cur = cur->next->next 

学到了，这是我自己写的代码：

ListNode* MyLinkedList::swapPairs(ListNode* head)
{
    ListNode* dummyHead = new ListNode();
    dummyHead->next = head;
    auto* cur = dummyHead;
    
    int idx = 0;
    while (cur->next != nullptr)
    {
        if (idx % 2 == 0 && cur->next->next !=nullptr)
        {
            auto* first = cur->next;
            auto* second = cur->next->next;

            first->next = second->next;
            second->next = first;
            cur->next = second;
        }

        idx++;
        cur = cur->next;
    }

    return dummyHead->next;
}

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

笨方法：

　　1，先得到正序情况下的下标

　　2，在对这个下标进行删除

需要注意：

　　1，idx >0

代码：

ListNode* MyLinkedList::removeNthFromEnd(ListNode* head, int n) 
{
    ListNode* dummyHead = new ListNode();
    dummyHead->next = head;
    ListNode* cur = dummyHead;

    int length = 0;
    while (cur->next != nullptr)
    {
        length++;
        cur = cur->next;
    }

    //不算头节点，从0开始 
    cur = dummyHead;
    int idx = length - n;
    while (idx > 0)
    {
        cur = cur->next;
        idx--;
    }


    if (cur->next != nullptr)
    {
        auto* mid = cur->next;
        cur->next = mid->next;
    }

    return dummyHead->next;
}

 聪明的方法：

// 对于倒数来说，主要的步骤是用快慢指针，他们两个的差，就是n
// 如果快指针指向的NULL，那么慢指针指向的就是问题节点
ListNode* MyLinkedList::removeNthFromEnd(ListNode* head, int n) 
{
    ListNode* dummyHead = new ListNode();
    dummyHead->next = head;
    ListNode* fast = dummyHead;
    ListNode* slow = dummyHead;

    // fast faster n than slow
    while (n>0)
    {
        fast = fast->next;
        n--;
    }

    while (slow->next != nullptr)
    {
        if (fast->next == nullptr)
        {
            auto* target = slow->next;
            slow->next = target->next;
            break;
        }
        slow = slow->next;
        fast = fast->next;
    }

    return dummyHead->next;
}

 链表相交

暴力解法版：

ListNode* MyLinkedList::getIntersectionNode(ListNode* headA, ListNode* headB) 
{
    ListNode* dummyHeadA = new ListNode();
    dummyHeadA->next = headA;
    ListNode* dummyHeadB = new ListNode();
    dummyHeadB->next = headB;

    ListNode* curA = dummyHeadA;
    ListNode* curB = dummyHeadB;
    while (curA->next != nullptr)
    {
        //注意每一轮都要把B初始化
        curB = dummyHeadB;
        while (curB->next != nullptr)
        {
            if (curA->next == curB->next)
            {
                return curA->next;
            }

            curB = curB->next;
        }
        curA = curA->next;
    }

    return nullptr;
}

 聪明的解法：

背景：

　　因为在链表的结构中，他们只能最后面是相等的，所以为了减少双循环，我们可以让他们齐头并进，只要从最短的链表长度那里出发，就可以解决问题了

代码：

// 因为A B 的链表结构，是他们的尾部都是相同的，所以我们可以直接移动到最短的链表的HEAD中
ListNode* MyLinkedList::getIntersectionNode(ListNode* headA, ListNode* headB) 
{
    ListNode* dummyHeadA = new ListNode();
    dummyHeadA->next = headA;
    ListNode* dummyHeadB = new ListNode();
    dummyHeadB->next = headB;

    ListNode* curA = dummyHeadA;
    ListNode* curB = dummyHeadB;
    
    int lengthA = 0;
    int lengthB = 0;
    //如何快速得到一个链表的长度？ -》 只能循环遍历
    while (curA->next != nullptr)
    {
        lengthA++;
        curA = curA->next;
    }
    while (curB->next != nullptr)
    {
        lengthB++;
        curB = curB->next;
    }
    //强制 A 最长， B最短
    if (lengthA < lengthB)
    {
        swap(lengthA, lengthB);
        swap(dummyHeadA, dummyHeadB);
    }

    curA = dummyHeadA;
    curB = dummyHeadB;
    
    int subLength = lengthA - lengthB;
    while (subLength--)
    {
        curA = curA->next;
    }

    while (curA->next != nullptr)
    {
        // 因为是一样的长度，所以不用使用For循环
        if (curB->next == curA->next)
            return curA->next;
        curB = curB->next;
        curA = curA->next;
    }

    return nullptr;
}

  142.环形链表II  

 1，使用数学的方法

1，原理　　

快慢节点，两个节点相遇的地方A，从开始的B 到 入口点C 的距离 == A -> C

2，需要注意的地方

　　即使设置了虚拟头，但是要注意，仍然是要从A开始移动，而不是A的前一位，因为 只要设置了虚拟头，那么B 就是虚拟头

3，代码

ListNode* MyLinkedList::detectCycle(ListNode* head)
{
    ListNode* dummyHead = new ListNode();
    dummyHead->next = head;

    auto* fast = dummyHead;
    auto* slow = dummyHead;

    // fast =  slow +1， 找到这两个指针相遇的节点
    auto* meetNode = new ListNode();
    while (fast->next != nullptr && fast->next->next!=nullptr)
    {
        //因为 fast slow都是从空头节点出发，所以meetNode 也要从空的头节点出发，
        if (fast->next->next == slow->next)
        {
            //不需要预留一位
            meetNode = slow->next;
            auto index1 = dummyHead;
            auto index2 = meetNode;

            // 因为存在没有环的情况，所以在这里进行判断
            while (index1->next != nullptr)
            {
                if (index1->next == index2->next)
                {
                    return index1->next;
                }

                index1 = index1->next;
                index2 = index2->next;
            }
        }

        slow = slow->next;
        fast = fast->next->next;
    }

    return NULL;
}

2，使用set