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

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

需要保存两个临时节点，cur->next 和 cur->next->next->next。注释部分的句子可以互换，需要注意的是此时的temp的值改变了，不再是cur->next 而是cur->next->next

/**
 * 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 != NULL && cur->next->next != NULL){
            ListNode* temp=cur->next;
            ListNode* temp1= cur->next->next->next;

            cur->next = cur->next->next;
            cur->next->next = temp;
            cur->next->next->next = temp1; // temp->next = temp1;

            cur = cur->next->next;
        }

        return dummyHead->next;
    }
};

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

双指针方法：先让前面的指针走n步，然后两个指针同时前进，知道前面的指针为NULL为止。

但是会遇到一个问题，fast指针指向空时，slow指针正好指向需要删除的指针，无法进行指针删除操作。所以，先让fast指针走n+1不，当fast指针指向NULL时，slow正好指向要删除节点的前一个节点。如此，执行 slow->next = slow->next->next ，就好啦！

/**
 * 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 =dummyHead;
        ListNode* slow =dummyHead;
        while(n-- && fast != NULL){
            fast = fast->next;
        }
        fast = fast->next;
        while(fast != NULL){
            fast = fast->next;
            slow = slow->next;
        }
        
        ListNode* temp = slow->next;
        slow->next = slow->next->next;
        delete temp;

        return dummyHead->next;

    }
};

面试题 02.07. 链表相交

由于两个链表相交之后就会一直相交（尾部相交），所以对于长度较长的一个链表来说，在尾部长度为稍短的链表之前，二者是不可能相交的。所以，先把较长的和较短的链表尾部对齐，并且对于较长的链表从较短链表头部的位置开始往后比较。

/**
 * 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 lenA = 0,lenB = 0;
        while(curA != NULL){
            lenA++;
            curA = curA->next;
        }
        while(curB != NULL){
            lenB++;
            curB = curB->next;
        }
        curA = headA;curB = headB;
        if(lenA < lenB){    //使A链表作为长的最长的链表
            swap(curA,curB);
            swap(lenA,lenB);
        }
        int len = lenA-lenB;
        while(len--) curA = curA->next;
        while(curA != NULL){
            if(curA ==curB){
                return curA;
            }
            curA = curA->next;curB = curB->next;
        }
        return NULL;
    }
};

142.环形链表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 != NULL && fast->next != NULL){
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow){    //如果快慢指针相遇，说明必定有环
                ListNode* index1 = head;
                ListNode* index2 = fast;
                while(index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;
    }

};