代码随想录训练营day4

（一）两两交换链表的节点

/**
 * 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 *dummy_head=new ListNode(0);
        dummy_head->next=head;
        ListNode *current=dummy_head;
        while(current->next!=NULL&&current->next->next!=NULL){
            ListNode *temp1=current->next;
            ListNode *temp2=current->next->next->next;

            current->next=current->next->next;
            current->next->next=temp1;
            current->next->next->next=temp2;

            current=current->next->next;
        }
        return dummy_head->next;
    }
};

（二）删除链表的倒数第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 *dummy=new ListNode(0);
        dummy->next=head;
        ListNode *slow=dummy;
        ListNode *fast=dummy;
        while(n--&&fast!=NULL){
            fast=fast->next;
        }
        fast=fast->next;
        while(fast!=NULL){
            slow=slow->next;
            fast=fast->next;
        }
        slow->next=slow->next->next;

        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) {
        ListNode *LenA;
        ListNode *LenB;
        int lengthA=0,lengthB=0;
        int chaju=0;
        LenA=headA;
        LenB=headB;
        while(LenA!=NULL){
            lengthA++;
            LenA=LenA->next;
        }
        while(LenB!=NULL){
            lengthB++;
            LenB=LenB->next;
        }

        LenA=headA;
        LenB=headB;

        if(lengthA>=lengthB){
            chaju=lengthA-lengthB;
            while(chaju--){
                LenA=LenA->next;
            }

            while(LenA!=NULL){
                if(LenA==LenB){
                    return LenA;
                }
                LenA=LenA->next;
                LenB=LenB->next;
            }

        }
        if(lengthA<lengthB){
            chaju=lengthB-lengthA;
            while(chaju--){
                LenB=LenB->next;
            }

            while(LenB!=NULL){
                if(LenA==LenB){
                    return LenB;
                }
                LenA=LenA->next;
                LenB=LenB->next;
            }

        }
        return NULL;
    }
};

（四）环形链表

/**
 * 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!=NULL&&fast->next!=NULL){
            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 NULL;
    }
};