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

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

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

        while (a->next != NULL&& a->next->next!=NULL) {
            ListNode* q = a->next->next;
            ListNode* w = a->next;
           a->next=a->next->next;
           w->next=a->next->next;
           a->next->next=w;
           a = a->next->next;
        }
        return dummy->next;
    }
};

这题把图画出来就秒了，主要是注意while循环的边界条件

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

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

    while(n--){
        a=a->next;
    }
    while(a!=NULL){
        a=a->next;
        b=b->next;
    }
    ListNode* tmp=b->next;
    b->next=b->next->next;
    delete(tmp);
    return dummy->next;
    }
};

主要思想是双指针，a提前走n步后shi让b跟上，最后当a指向null时b指向倒数第n个数之后删除即可

 面试题 02.07. 链表相交  

class Solution {
public:
    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
        int flag = 0;
        ListNode* ans;
        int i = 0, j = 0;
        ListNode* a1 = headA;
        ListNode* b1 = headB;
        for (; a1 != NULL; a1 = a1->next) {
            i++;
        }
        for (; b1 != NULL; b1 = b1->next) {
            j++;
        }
        ListNode* a = headA;
        ListNode* b = headB;
        if (i >= j) {
            int y = i - j;
            while (y--) {
                a = a->next;
            }
            while (a != NULL) {

                if (a == b) {
                    if(flag==0)
                    ans = a;
                    flag = 1;
                    
                }
                if (a != b)
                    flag = 0;
                a = a->next;
                b = b->next;
            }
        }

        else {
            int y = j - i;
            while (y--) {
                b = b->next;
            }
            while (a != NULL && b != NULL) {

                if (a == b) {
                    if(flag==0)
                    ans = a;
                    flag = 1;
                    
                }
                    if (a != b)
                        flag = 0;
                    a = a->next;
                    b = b->next;
                }
            }
        
    
    if (flag == 0)
        return NULL;
    return ans;
}
}
;

主要注意是链表的地址相同，如果一开始就认为是val的值相同就错了

 142.环形链表II  

class Solution {
public:
    ListNode* detectCycle(ListNode* head) { 
        if(head==NULL)
        return NULL;
        ListNode* fast = head;
        ListNode* slow =head; 
        while(fast->next!=NULL&&fast->next->next!=NULL){
            fast=fast->next->next;
            slow=slow->next;
            if(fast==slow){
                ListNode* a=fast;
                ListNode* b=head;
            while(a!=b){
                a=a->next;
                b=b->next;
            }
            return a;
            }
          
        }
          return NULL;
        }
};

这题主要是要搞懂数学关系，先当快指针遇到慢指针时说明遇到了环，之后可以用数学表达式解出当一个指针从head与在相交位置的指针同时出发相交的位置即为环的入口，又因为

所以两指针一定会slow走完第一圈之前相遇