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

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

文章链接/视频链接：24. 两两交换链表中的节点

题目描述
24. 两两交换链表中的节点

题解

1. 当且仅当cur指向待两两交换节点的上一个节点时，可两两交换节点。
2. while(cur->next && cur->next->next)，当且仅当“cur->next”不为空，可访问cur->next->next，因而二者顺序不可交换。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* cur = dummyHead;

        while(cur->next && cur->next->next) {
            ListNode* tmp0 = cur->next;
            ListNode* tmp1 = cur->next->next->next;
			
			// 两两交换节点
            cur->next = cur->next->next;
            cur->next->next = tmp0;
            tmp0->next = tmp1;

            cur = cur->next->next;
        }

        return dummyHead->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) {}
 * };
 */

时间复杂度：O(n)
空间复杂度：O(1)

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

文章链接/视频链接：19.删除链表的倒数第N个节点

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

题解

1. 利用快慢指针查找链表倒数第n个节点。令快指针移动n步后快慢指针同时移动直至快指针指向nullptr，此时慢指针指向链表倒数第n个节点。
2. 删除某个节点需获取目标节点的上一个节点，故本题慢指针最终应指向链表倒数第n+1个节点，则令快指针移动n+1步。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;

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

        while (fast) {
            fast = fast->next;
            slow = slow->next;
        }
        
        ListNode *tmp = slow->next; 
        slow->next = slow->next->next;
        delete tmp;
        
        return dummyHead->next;
    }
};

时间复杂度：O(n)
空间复杂度：O(1)

面试题 02.07. 链表相交

文章链接/视频链接：面试题 02.07. 链表相交

题目描述
面试题 02.07. 链表相交

题解

1. 令curA指向headA，curB指向headB，遍历后得各链表长度lenA、lenB。
   
2. 重置指针curA、curB并比较lenA、lenB，令curA指向较长链表头节点，lenA为较长链表长度。
3. 将curA左移链表长度差值位，使得curA指向与curB链表末尾对齐后并列的元素。
   

源代码

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;

        int lenA = 0, lenB = 0;
        while(curA) {
            curA = curA->next;
            lenA++;
        }
        while(curB) {
            curB = curB->next;
            lenB++;
        }
		
		// 重置指针
        curA = headA; 
        curB = headB;

        // 使得curA指向较长链
        if(lenA < lenB) {
            swap(curB, curA);
            swap(lenB, lenA);
        }
		
		// 对齐curA、curB
        int gap = lenA - lenB;
        while(gap) {
            curA = curA->next;
            gap--;
        }

        while(curA) {
            if(curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }

        return nullptr;
    }
};

时间复杂度：O(m+n)
空间复杂度：O(1)
m、n分别为curA、curB链表长度。

142.环形链表 Ⅱ

文章链接/视频链接：142.环形链表 Ⅱ

题目描述
142.环形链表 Ⅱ

题解

1. 令快指针、慢指针分别指向head，快指针移动2步，慢指针移动1步，若快慢指针相遇则链表有环。
2. 快慢指针相遇后令index0由head出发，index1由快慢指针相遇节点出发，二者相遇节点即环入口。

另

1. 快指针以相对慢指针每次移动1步的速度接近慢指针，故快慢指针一定能相遇。
2. 由头节点出发至环入口的距离等于快慢指针相遇节点至环入口的距离，详细数学推导可参考142.环形链表 Ⅱ。
3. 如图所示将各环平摊，慢指针移动一圈内即与快指针相遇。
   

源代码

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;

        while(fast != nullptr && fast->next != nullptr) {
            fast = fast->next->next;
            slow = slow->next;

            if(fast == slow) {
                ListNode* index0 = head;
                ListNode* index1 = slow;

                while(index0 != index1) {
                    index0 = index0->next;
                    index1 = index1->next;
                }

                if(index0 == index1) {
                    return index0;
                }
            }
        }

        return nullptr;
    }
};

时间复杂度：O(n)
空间复杂度：O(1)
快慢指针相遇前指针移动次数小于链表长度n，快慢指针相遇后，index指针移动次数小于链表长度n，即总移动次数小于2n。

后记
第四天！
再接再厉～
：）