代码随想录算法训练营04 | 206.反转链表、24.两两交换链表中的节点、142.环形链表||、面试题02.07.链表相交

11. 两两交换链表中的结点

C++：

代码随想录中的方法，思想是，先连接上一个虚拟的头结点，然后交换结点的指向，从而实现交换链表中的结点

/**
 * 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;

            cur = cur->next->next;

        }
        return dummyHead->next;
    }
};

需要说明的是，链表的指向交换了之后，在再次使用的时候，就要按照交换后的指向来进行指引了，不要还按照没交换前的指向来考虑，那样就会发现，代码似乎有误？！反正我没想明白前是犯了这个错误，哈哈

12. 删除链表的倒数第N个结点

C++：

这个算法中，值得学习的是，设置了快慢指针，然后让快指针先走 n+1 步，精髓就在此，这样的话，当fast指针是null的时候，slow正好指向要删去的结点的前一个结点，那么只要让slow指针的结点指向下下一个结点，就完成了删去结点的目的！谁想出来的方法，太聪明了！

/**
 * 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;
        }

        // slow->next = slow->next->next;
        ListNode* temp = slow->next;
        slow->next = slow->next->next;
        delete temp;

        return dummyHead->next;
    }
};

带有注释的地方写的是清除内存的方法，和没清除内存的方法

13. 链表相交

C++：

这里的算法，值得学习的是，要用长链表的长度减去短链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置。此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。否则循环退出返回空指针。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != NULL) { // 求链表A的长度
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) { // 求链表B的长度
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap--) {
            curA = curA->next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

就是求两个链表交点节点的指针。 这里要注意，交点不是数值相等，而是指针相等 这句话还需要再理解理解，因为在比较的时候，确实比较的就是指针，而不是对应的数值。

下面说一下自己输入的时候错误的地方：

• 在完成统计链表的长度之后，当前结点的指向就是null了，我没有进行 curA = headA;curB = headB; 将结点位置前移再进行后续的操作，这个需要注意；
• 在进行最后的比较的时候，忘记在比较后将结点后移了。粗心

14. 环形链表

这里面思路挺简单，主要分为两部，查找是否有环，有环的话，找到环入口，看看代码也能看懂，主要是想给自己记录一下，为什么第一次在环中相遇，slow的 步数 是 x+y 而不是 x + 若干环的长度 + y 呢？

自己的疑惑是，可能slow已经走了好几圈了，然后俩才相遇，结合代码随想录上的描述，简要提醒自己一下：在得出slow到达环口，fast必定在环内的结论后，下面的那个图的分析，意义就是判定，在slow没走完那一圈之前，fast就可以与它完成相遇（slow与fast，只有在同时到达环口的时候，slow才有机会在刚好走完一圈的时候与fast相遇，那么，既然fast已经在环内了，那么fast必定会在slow未完成一圈的情况下与fast相遇）

/**
 * 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* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2;
            }
        }
        return -1;
    }
};

需要强调一点的是，在一个while循环中，那个判断条件 fast != NULL && fast->next != NULL fast自己的地址不是空，结点的指向也不是空，意思就是，如果这个结点的下下一个就是null，那它经过循环后就直接指向null了，那循环就结束了，如果说自己指向null或者下一个指向是null，那就预示着链表到头了，那自然就没必要再循环判断了，结束了还有个啥的环