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

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

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

题目链接: 24.两两交换链表中的节点

要求不能改变结点内部的值，需进行实际性的交换

首先采用虚拟头结点，然后考虑交换相邻结点

class {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0);  //设置虚拟头结点
        dummyHead->next = head;  //将虚拟头结点指向head，方便后面做删除操作
        ListNode* cur = dummyHead;
        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;  //步骤二：将记录的临时结点更换到当前结点的连续两个指向
            cur->next->next->next = tmp1;  //步骤三：将更换后的结点恢复指向下一个
            
            cur = cur->next->next;  //完成相邻结点的更换，cur移动两位，准备下一轮交换
        }
        reture dummyHead->next;  //返回头结点
    }
};

注：该方法时间复杂度为O(n)，空间复杂度为O(1)

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

题目链接: 19.删除链表的倒数第N个节点

思路：首先使用虚拟头结点，然后采用双指针法，让fast移动n步，接着让fast和slow同时移动，直到fast指向链表末尾，最后删掉slow所指向的结点

class Solution {
public:
    ListNode* removeNthFormEnd(ListNode* head, int n) {
        //设置虚拟头结点
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n--  && fast != NULL) {
            fast = fast->next;  //fast向前移动n
        }
        fast = fast->next;  //此处让fast一共向前移动了n+1，为方便删除slow->next
        //双指针共同向前移动，直到fast移动到尾结点
        while(fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        //此处未进行释放内存
        return dummyHead-next;
    }
};

LeetCode 面试题 02.07题 链表相交

题目链接: 面试题 02.07. 链表相交

思路：分别求出两个链表A和B的长度，并求出两个链表长度的差值，然后让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;  //求长度差
        while(gap--) {
            curA = curA->next;  //使curA和curB末尾对齐
        }
        while(curA != NULL) {
            if(curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

注：该算法时间复杂度为O(n+m)，求两个链表交点结点的指针，但是注意理解交点不是数值相等，而是指针相等。

LeetCode 142题 环形链表II

题目链接: 142.环形链表II

思路：

1. 证明有环：分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。
2. 寻找环入口：假设头结点到环入口的结点数为x，从环形结点到fast与slow相遇结点数为y，从相遇结点再到环形入口结点数为z，推导整理公式为：x = (n - 1) (y + z) + z

双指针法

class Solution {
public:
    ListNode* detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fsat->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            if(fast == slow) {  //当fast和slow相遇
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while(index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2;
            }
        }
        return NULL;
    }
};