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

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

思路：首先创建一个虚拟头节点指向源头节点head，设置一个cur指针指向虚拟头节点（xunihead）来进行交换操作。进行交换的思路是，首先head和head->next的交换，在实现这两个节点的交换过程中，我们会遇到一些问题。注意：要分节点的数量奇偶来也定终止条件，交换节点时，操作指针一定要指到的是第一个节点的前一个节点，最后返回dummyhead->next的值就好。

第一种情况就是节点数是偶数，cur->next为空是结束循环，两两交换一定是不多不少刚刚好，但是如果是奇数，有多一个但是没法进行交换也不行，终止条件就是cur->next->next为空。

在进行交换时，要注意建立临时指针保存该保存的链表，比如，这里的cur->next和cur->next->next进行交换时，因为要cur与cur->next在交换后会断开，导致无法在访问原来的cur->next，先建立一个临时指针来保存。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* xunihead = new ListNode(0);
        xunihead->next = head;
        ListNode* cur = xunihead;
        while(cur->next != nullptr && cur->next->next != nullptr){
            ListNode* tmp = cur->next;
            ListNode* tmp1 = cur->next->next->next;


            cur->next = cur->next->next;
            cur->next->next = tmp;
            tmp->next = tmp1;
            cur = cur->next->next;
        }
        return xunihead->next;
    }
};

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

思路：

1、暴力解法，先遍历链表，求出链表的长度记为length，然后用length-n，能得到第n-1个节点，对第n个节点进行删除，代码如下

2、双指针：定义快慢两个指针，快指针先走n步，然后慢指针开始同事向后走，当快指针下一个节点为空时，慢指针就会达到第n-1个节点，此时正好就可以进行删除操作。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        int length = 0;
        ListNode* cur = dummy;
        while(cur->next != nullptr){
            cur = cur->next;
            length++;
        }
        int n1 = length-n;
        ListNode* cur1 = dummy;
        while(n1--){
            cur1 = cur1->next;
        }
            cur1->next = cur1->next->next;
            return dummy->next;
    }
};

lass Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* fast = dummy;
        ListNode* slow = dummy;
        while(n--){
            fast = fast->next;
        }
        while(fast->next != nullptr){
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        return dummy->next;
    }
};

面试题 02.07. 链表相交

思路：链表有长有短，链表相交肯定是长链表在找短链表，我们这里定义有两个链表，定义A为长链表，B为短链表，那这样我们要设计一个判断的函数，当B的长度大于A时，我们先交换A,B的长度，再交换A,B的头节点，这样来保证A是长链表。完成之后，我么求出长度差，来控制指针指向A，B相同的位置，然后开始比较，遇到相等直接返回

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0,lenB = 0;
        while(curA != NULL){
            curA = curA->next;
            lenA++;
        }
        while(curB != NULL){
            curB = curB->next;
            lenB++;
        }
        curA = headA;
        curB = headB;
        //让长的链表做A链表
        if(lenB > lenA){
            swap(lenA,lenB);
            swap(curA,curB);
        }
        //去链表长度差，
        int lengthgap = lenA - lenB;
        while(lengthgap--){
            curA = curA->next;
        }//遍历长链表，当长度差为零时，长短链表对齐
        //两个链表此时一起遍历，遇到相同的直接返回
        while(curA != NULL){
            if(curA == curB){
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

，没有就返回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(slow == fast){
                ListNode* index1 = head;
                ListNode* index2 = fast;
                while(index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;
    }
};