算法记录 04 | 24.两两交换链表中的节点 ，19.删除链表的倒数第N个节点， 链表相交 ，142.环形链表II

今日更新题目：24.两两交换链表中的节点 ，19.删除链表的倒数第N个节点， 链表相交 ，142.环形链表II

以后就不贴题目原文了，除非有很重要的提示。

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

只要是存在处理头结点的操作，都建议用虚拟头结点，这样会方便很多，关于设置和删除虚拟头结点的注意事项，上篇博客也讲过了。接下来就是简单的交换操作了，交换操作只要保证一点：自己模拟的过程不会丢到某个结点且第二轮交换的模拟也是成功的即可，只要不丢掉结点，方法都是可行的。例如，我的步骤和代码随想录的步骤就刚好反过来，但是没有丢失结点。

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* tmp = cur->next->next;
            cur->next->next = tmp->next;
            tmp->next = cur->next;
            cur->next = tmp;
            cur = cur->next->next;
        }
        head = dummyhead->next;
        delete dummyhead;
        return head;
    }
};

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

本题难点在于定位到待删除结点，由于单链表的性质，只能顺序查找，所以本体采用快慢指针法，让快指针先走N步，然后快慢指针同时走，当快指针走到链表尾时，则慢指针也到达了待删除结点的位置的前一个位置。另外，由于可能会删除链表第一个结点，所以本体采用虚拟头节点统一处理，具体如下

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;
        }
        while(fast->next){
            slow = slow->next;
            fast = fast->next;
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;
        head = dummyhead->next;
        delete dummyhead;

        return head;
    }
};

链表相交

本题需要找到相交起点，要找到相交起点就需要判断两指针所指位置是否相同，所以两指针需要同时到达相交结点，那就要根据两个链表长度只差，决定谁先出发，先走几步，想到这就能想到快慢指针法了。

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

        while(curA != NULL){
            curA = curA->next;
            lenA++;
        }
        while(curB != NULL){
            curB= curB->next;
            lenB++;
        }

        curA = headA;
        curB = headB;
        int gap = abs(lenA - lenB);

        while(gap--){
            if(lenA > lenB)
                curA = curA->next;
            else
                curB= curB->next;
        }

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

环形链表II

本题主要分两步：

• 判断链表是否环
• 如果有环，如何找到这个环的入口

判断链表是否环：我个人是只会第一步的，也就是快慢指针法，若有环，快指针是肯定会追上慢指针的，只要保证快指针一次走两步，慢指针一次走一步，就不会有直接越过慢指针的情况；若无环，则指针最终会各自遍历到链表末尾，判空即可。

寻找环入口：基本思路就是围着下图所给关系列方程，这里直接忽略代码随想录中的n（懒得推了），假设第一圈后相遇（再多走n圈也是一个道理，变成周期问题），即

• 快指针已走：x+y+z+y
• 慢指针已走：x+y
• 关系：快指针速度是慢指针两倍，则走的路程也是慢指针两倍，则多走的 x+y+z+y = 2*(x+y)，易得 x=z

意思就是相遇点出发一个指针，头结点再出发一个指针，都走一步，经过x步，就是环入口（有点类似上一题，找两个链表交点，一个链表是从头结点到入口节点，另一个链表是从入口节点绕一圈到入口节点，另一个链表先走了y步，使其剩下的路程相同）

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

引用

代码随想录