397-链表（206.反转链表 & 24. 两两交换链表中的节点 & 19. 删除链表的倒数第 N 个结点 & 面试题 02.07. 链表相交 & 142.环形链表II）

206.反转链表

class Solution {
public:
    ListNode* reverseList(ListNode* head) {

        ListNode* cur = head;
        ListNode* pre = nullptr;
        ListNode* temp = nullptr;

        while (cur != nullptr)
        {
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }

        return pre;
    }
};

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

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummynode = new ListNode(0);
        dummynode->next = head;
        ListNode* cur = dummynode;

        while (cur->next != nullptr && cur->next->next != nullptr)
        {
            ListNode* tmp1 = cur->next;
            ListNode* tmp2 = cur->next->next->next;

            cur->next = cur->next->next;
            cur->next->next = tmp1;
            cur->next->next->next = tmp2;

            cur = cur->next->next;
        }

        return dummynode->next;
    }
};

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

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        
        ListNode* dummynode = new ListNode(0);
        dummynode->next = head;

        ListNode* fast = dummynode;
        ListNode* slow = dummynode;

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

        //让fast多走一步，这样slow就位于要删除节点的前面一个节点！
        fast = fast->next;

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

        //此时slow位于要删除节点的前一个节点
        slow->next = slow->next->next;

        return dummynode->next;
    }
};

面试题 02.07. 链表相交

class Solution {
public:
    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;

        int lenA = 0;
        int lenB = 0;

        while (curA != nullptr)
        {
            lenA++;
            curA = curA->next;
        }

        while (curB != nullptr)
        {
            lenB++;
            curB = curB->next;
        }

        curA = headA;
        curB = headB;

        if (lenB > lenA)
        {
            swap(lenA, lenB);
            swap(curA, curB);
        }

        int gap = lenA - lenB;

        while (gap--)
        {
            curA = curA->next;
        }

        while (curA != nullptr)
        {
            if (curA == curB)
            {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return nullptr;
    }
};

142.环形链表II

class Solution {
public:
    ListNode* detectCycle(ListNode* head) {
        ListNode* fast = head;
        ListNode* slow = head;

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

            if (fast == slow)
            {
                ListNode* index1 = fast;
                ListNode* index2 = head;

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