代码随想录算法训练营第4天 | 24, 19，面试题02.07

24

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummy_node = new ListNode(0, head);
        ListNode* p = dummy_node;
        while (p->next != nullptr) {
            ListNode* f = p->next;
            if (f->next == nullptr) {
                break;
            }
            ListNode* s = f->next;
            ListNode* n = s->next;
            p->next = s;
            s->next = f;
            f->next = n;

            p = p->next->next;
        }
        return dummy_node->next;
    }
};

总结: 画图+虚拟头节点

 19

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy_node = new ListNode(0, head);
        ListNode* fast = dummy_node;
        ListNode* slow = dummy_node;

        while (n>0) {
            fast = fast->next;
            n--;
        }
        if (fast == nullptr) {
            return nullptr;
        }
        while (fast->next!=nullptr) {
            slow = slow->next;
            fast = fast->next;
        }
        slow->next = slow->next->next;
        
        return dummy_node->next;
    }
};

双指针运用，从dummy开始，fast先走n步，判断结束条件是fast直到最后一个node。删除的是slow的下一个node，所以直接赋值slow->next.

面试题 02.07

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int lenA=0;
        int lenB=0;

        ListNode* currA = headA;
        while (currA != nullptr) {
            lenA++;
            currA = currA->next;
        }
        ListNode* currB = headB;
        while (currB != nullptr) {
            lenB++;
            currB = currB->next;
        }

        currA = headA;
        currB = headB;

        int gap = lenA>lenB? lenA-lenB : lenB-lenA;
        if (lenA>lenB) {
            while (gap>0) {
                currA = currA->next;
                gap--;
            }
        }
        else {
            while (gap>0) {
                currB = currB->next;
                gap--;
            }
        }


        while (currA!= nullptr && currB!= nullptr && currA!=currB) {
            currA = currA->next;
            currB = currB->next;
        }
        if (currA== nullptr || currB== nullptr) {
            return 0;
        }
        return currA;
    }
};

写过的题但思路还是有点忘记

思路：因为两个链表最后相交，末尾是一样的，所以应该先向右对齐两个链表（即第一遍遍历先找出长度差，再对齐）然后同步遍历找到交点

142

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

        while (fast != nullptr &&fast->next != nullptr) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) {
                ListNode* index2 = fast;
                ListNode* index1 = head;
                while (index1!=index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return nullptr;
        
    }
};

快慢指针，快指针跑两格，慢指针一格。

note：每次两个指针要同时加，不能在快指针已经追上慢指针的时候就不加慢指针的了，这样没法找布数关系。

重点是画图，发现从相遇点到入圈点和从头到入圈点距离相等。