【代码随想录】算法训练营 第四天 第二章 链表 Part 2

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

思路

为了使得头结点的处理不用特殊化，所以依然设置一个虚拟头结点dummy，每次要交换的时候都要判断接下来的两个结点是否为空结点，即nullptr，若非空即可交换；

交换的时候，用一个指针保存第一个结点，用另一个指针保存两个结点后的一个结点，为什么不保存第二个用于交换的结点呢？因为在后面重新连接结点时，前一个结点必须连接第三个结点，所以得先存着，不然交换后就找不到了。

代码

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* cur = dummy;
        while (cur->next != nullptr && cur->next->next != nullptr) {
            ListNode* tmp1 = cur->next; // 暂存要交换的第一个结点
            ListNode* tmp2 = cur->next->next->next; // 暂存交换结点的后一个结点
            cur->next = cur->next->next;
            cur->next->next = tmp1;
            cur->next->next->next = tmp2; // 从第一个开始，三个找下家
            cur = cur->next->next; 
        }
        return dummy->next;
    }
};

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

题目

思路

使用双指针法，一快一慢，快的在前面跑，离慢的要有n+1个结点，这样的话，如果快指针指到空了，就可以删除慢指针指向结点的下一个结点；

这里依然需要设置虚拟头结点，而且快指针要先跑n个结点后，再跑到下一个结点，前n个结点要保证快指针指向的结点非空，因为题目都要求倒数第n个了，所以至少也要有n个非空结点，接下来再往下跑一个的话就不用保证了，空也可以。

代码

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* fast = dummy;
        ListNode* slow = dummy;
        while (n-- && fast != nullptr) {
            fast = fast->next;
        }
        fast = fast->next;
        while (fast != nullptr) {
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;
        return dummy->next;
 
    }
};

面试题 02.07. 链表相交

题目

思路

这道题也用不上算法，因为两个链表要么存在最后几个结点全部相同，要不就不存在相交，所以可以先将两个链表中长的一条缩短到短的那条的长度，那样就可以对剩下的相同长度的结点进行一一比较了，只要遇到相同的结点，就直接返回这个结点的指针即可，因为这道题中不会出现其他特殊情况。

代码

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != nullptr) {
            lenA++;
            curA = curA->next;
        } 
        while (curB != nullptr) {
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        if (lenB > lenA) {
            swap (lenB, lenA);
            swap (curB, curA);
        }
        int gap = lenA - lenB;
        while (gap--) {
            curA = curA->next;
        }
        while (curA != nullptr) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

142. 环形链表 ll

题目

思路

画图模拟即可，但是还是要结合数学推导，推导详见代码随想录，这里我来概括一下主要思路；

首先，我们要判断一个链表是否存在闭环，可以设置一个快指针和一个慢指针，快指针每次向前移动两个结点，慢指针移动一个结点，如果存在闭环的话，那么快慢指针一定会相遇，因为快指针和慢指针之间有相对速度，虽然一开始快指针移动较快，但是它也会先进入闭环，快指针总会在闭环中追上后来的慢指针，经由数学推导得知，闭环开始的地方与头结点的距离和闭环开始的地方与相遇处的距离相等，这样就可以用代码实现了。

代码

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