刷题第四天

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

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

有一个点学到了 while循环那里的cur->next!=nullptr&&cur->next->next!=nullptr 顺序不要错了

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(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;
            temp1 = temp->next;
            cur = temp;
        }
        return dummyhead->next;
    }
};

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

快慢指针，主要是思路

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *dummyhead = new ListNode(0);
        dummyhead ->next = head;
        ListNode *fast_point = dummyhead;
        ListNode *slow_point = dummyhead;
        n++;
        while(n--&&fast_point!=nullptr){
            fast_point = fast_point->next;
        }
        while(fast_point!=nullptr){
            fast_point = fast_point->next;
            slow_point = slow_point->next;
        }
        ListNode* temp = slow_point->next;
        slow_point->next = slow_point->next->next;
        delete temp;
        temp = nullptr;
        return dummyhead->next;
    }
};

链表相交

重点在于链表如果相交，后面的长度一定一样，然后再比较指针就行，leetcode的方法一看就贼高级贼简洁，但是没看懂，烦

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *curA = headA;
        ListNode *curB = headB;
        int length_a = 0;
        int length_b = 0;
        while(curA!=nullptr){
            curA = curA->next;
            length_a++;
        }
        while(curB!=nullptr){
            curB = curB->next;
            length_b++;
        }
        curA = headA;
        curB = headB;
        if(length_b>length_a){
            swap(length_a,length_b);
            swap(curA,curB);
        }
        int gap = length_a-length_b;
        while(gap--){
            curA = curA->next;
        }
        while(curA!=nullptr){
            if(curA == curB){
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return nullptr;
    }
};

环形链表II

很有意思，得先想到fast走两步 slow走一步 ，然后就变成一道数学题了，学到了

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
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 index2;
            }
        }
        return nullptr;
    }
};