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

---

---

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

力扣题目链接

代码如下：

/**
 * 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;//虚拟头节点和head链接
        ListNode* cur = dummyHead;//遍历指针cur初始指向dummyHead，因为要操作后两个节点

        while (cur->next != NULL && cur->next->next != NULL){
            //当链表节点个数为偶数时，如4，cur依次指向dummyHead、第2节点、第4节点，此时cur->next为NULL，循环终止
            //当链表节点个数为奇数时，如5，cur依次指向dummyHead、第2节点、第4节点，此时cur->next->next为第五节点后的NULL，即只剩最后一个第五节点，不用交换，循环终止
            //注意！！！【while中的顺序】必须先写cur->next != NULl后写cur->next->next != NULL，否则，若cur->next已经为空（偶数时），cur->next->next无法操作空指针

        ListNode* tmp = cur->next;//(a)提前保存cur后第一节点的地址
        ListNode* tmp1 = cur->next->next->next;//(b)提前保存cur第二节点的地址

        cur->next = cur->next->next;//【步骤1】将cur指向cur后第二节点，例如：将dunmmyHead指向第2个节点
                                    //这里需要注意！因为将cur指向后面第二个节点后，cur后一个节点的地址也无法获取了，这样就不能操作后一个节点（后一个节点需要指向后面第三个节点）
                                    //因此，需要在这步操作前，将cur->next的地址先保存在临时指针tmp中，见标记（a）的语句
        cur->next->next = tmp;//【步骤2】cur后第2节点指向第1节点原来的地址
        tmp->next = tmp1;//【步骤3】cur后第1节点指向第3节点
                //同理，cur后第3节点也需要提前保存地址（b），因为在上一行代码中，cur后第2节点的next指向已经发生改变，无法获取cur后第3节点的地址，也就无法操作第3节点
                //为什么不用提前保存cur后第2节点的地址呢？因为在cur->next = cur->next->next中，cur后第二节点的地址已经保存在cur->next中了，可以直接操作cur后第二节点

        cur = cur->next->next;//cur向后移两位，以操作下一对节点
        }
        return dummyHead->next;//返回链表的头节点，不能是head哦！因为head已经和后一节点交换过了，虚拟头节点指向的才是真正的链表头节点

    }
};

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

力扣题目链接

使用快慢双指针的方法，两指针起始都指向虚拟头节点，快指针先移动n+1个单位（因为这样才能使快慢指针同时移动时slow指针指向需要删除节点的上一个节点）。此时slow与fast之间的距离为n+1，在将两个指针同时移动，直到fast移动到NULL，此时slow指向的就是倒数第n+1个节点，删除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;

            n++;
            while (n-- && fast != NULL ) {
                fast = fast->next;
            }

            while (fast != NULL){
                fast = fast->next;
                slow = slow->next;
            }

            slow->next = slow->next->next;
            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) {//计算A链表的长度
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) {//计算B链表的长度
            lenB++;
            curB = curB->next;
        }
        
        curA = headA;//这一步别忘了！计算完长度后两个cur都是指向NULL，需要恢复指向头节点
        curB = headB;

        if (lenB > lenA) {//为保证差值是个正数
            swap (lenA, lenB);
            swap (curA, curB);//交换链表名称，cur指针也要交换
        }
        int gap = lenA - lenB;//计算链表长度差值

        while (gap--) {
            curA = curA->next;//长的链表，指针先移动gap位，为了使两链表尾部对齐
        }

        while (curA != NULL) {//两个指针同时向后移动
            if (curA == curB){//交点不是值相等！而是指针都相等！
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;


    }
};

四、142.环形链表II

题目链接

卡哥讲解

代码如下：

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