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

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

开始写的代码总有一些问题，对比答案之后发现自己少设置了一个变量，（此前想偷懒，把cur和head融合到一块了）。

此题我出现的问题，还有一点在于自己忘了指针的作用了，一直奇怪head节点改变后，为什么dummyhead->next依然正确

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyhead = new ListNode(0);
        dummyhead->next=head;
        ListNode* cur = dummyhead;//指针可以直接修改变量的值，此处忘了指针的作用了
        while (cur->next != nullptr && cur->next->next != nullptr){
            ListNode* temp = cur->next;
            ListNode* temp1 = cur->next->next->next;

            cur->next=cur->next->next;
            cur->next->next=temp;
            cur->next->next->next=temp1;
            cur = cur->next->next;;
        }
        return dummyhead->next;
        
    }
};

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

此题的进阶版题解中给了提示，只需要遍历一遍就可得到结果，所以我们可以将其看作链表版的删除数组元素题，使用双指针里快慢指针的操作便可以只遍历一次。需要注意的问题依然是越界问题。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int fast = 1;
        int slow = 1;
        ListNode* dummyhead = new ListNode(0);
        dummyhead->next=head;
        ListNode* cur = head;
        ListNode* pre = dummyhead;
        while (cur->next != nullptr){
            fast++;
            cur=cur->next;
            if (fast-slow == n){
                slow++;
                pre=pre->next;
            }
        }
        pre->next=pre->next->next;
        return dummyhead->next;
    }
};

面试题 02.07. 链表相交 

一开始自己的思路比较简单，写出了以下代码，运行错误后才注意到节点位置在链表中位置不等长。后续修改为第二段代码，我的思路是，两个链表如果不等长，那就让它一直循环，直到最后同时结束时，仍未出现交点则输出nullptr。这种做法时间比较长，因此就有了第三段代码，此处照抄了答案，因为确实没想到这种方法，值得后续学习。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA || headB) return nullptr;
        ListNode* A = headA, * B = headB;
        while (A != B){
            if (A){
                return nullptr;
            } else {
                A = A->next;
            }
            if (B){
                return nullptr;
            } else {
                B = B->next;
            }
        }
        return A;
    }
};

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (!headA || !headB) return nullptr;
        ListNode* A = headA, * B = headB;
        while (A != B){
            if (!A && !B) return nullptr;
            if (!A){
                A=headA;
            } else {
                A = A->next;
            }
            if (!B){
                B = headB;
            } else {
                B = B->next;
            }
        }
        return A;
    }
};

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (!headA || !headB) return nullptr;
        ListNode* A = headA, * B = headB;
        while (A != B){
            if (!A){
                A=headB;
            } else {
                A = A->next;
            }
            if (!B){
                B = headA;
            } else {
                B = B->next;
            }
        }
        return A;
    }
};

142.环形链表II 

偷了个懒，没用快慢指针，使用哈希表做的。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_set map;
        while (head != nullptr){
            if (map.count(head)){
                return head;
            }
            map.insert(head);
            head=head->next;
        }
        return nullptr;
    }
};