Day04

/**
 * 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) {
        if(head==nullptr || head->next==nullptr) return head;
        
        ListNode* pre=new ListNode(0);
        pre=head;
        ListNode* cur;
        cur=head->next;
        

        while(cur!=nullptr){
            ListNode* tmp=new ListNode(0);
            tmp->val=pre->val;
            pre->val=cur->val;
            cur->val=tmp->val;
            delete tmp;
            if(cur->next!=nullptr){
            pre=cur->next;}else break;
            if(pre->next!=nullptr)
            cur=pre->next;
            else break;

        }

        return head;

    }
};

/**
 * 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* dummy=new ListNode(0);
        dummy->next=head;
        int length=0;
        ListNode* p=head;
        while(p->next!=nullptr){p=p->next;length++;}
        ListNode* cur=dummy->next;
        ListNode* pre=dummy;
        for(int i=0;i<length-n+1;i++){
            if(pre->next==nullptr || cur==nullptr) break;
            pre=pre->next;
            cur=cur->next;
        }
        if(pre->next!=nullptr && cur!=nullptr){
            
            pre->next=cur->next;
            delete cur;
        }

        return dummy->next;

    }
};

/**
 * 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) {
        
        if(!headA || !headB) return NULL;

        ListNode* curA= headA;
        ListNode* curB= headB;

    
        int lena=0,lenb=0;


         while(curA!=nullptr ){
         
         lena++;
         curA=curA->next;
         
         }
          while(curB!=nullptr ){
         
         lenb++;
         curB=curB->next;
         
         }

        ListNode* res=nullptr;

        curA= headA;
        curB= headB;

        if(lena<lenb){
            curA=headB;
            curB=headA;
            swap(lena,lenb);
            }
            
      for(int i=0;i<lena-lenb;i++){
                curA=curA->next;
            }
        
        
        while(curA!=nullptr ){
            
            if(curA==curB)  {
                res=curA;
                break;
                }

            curA=curA->next;
            curB=curB->next;

        }
        return res;
    }
    
};

判断有无环：快慢指针是否相遇，快指针步长可以比慢指针大

/**
 * 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){
            slow=slow->next;
            fast=fast->next->next;
            if(fast==slow){
                ListNode* index1=fast;
                ListNode* index2=head;

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

        }
                return NULL;
    }
};