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

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

题目链接LC24
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

输入：head = [1,2,3,4]
输出：[2,1,4,3]

输入：head = []
输出：[]

思路：

1. 首先想到要改变某个位置的链表指向，那么一定要知道该位置的前一个节点，所以先设置一个虚拟头节点指向真正的头节点，然后进行交换操作。
2. 然后定义两个临时变量储存交换过程中的节点。
3. 在交换的过程中，要依次交换，避免出错

class Solution 
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0); // 构建虚拟头节点
        dummyHead->next = head; // 虚拟头节点指向链表头
        ListNode* pre = dummyHead; // 构建指针指向虚拟头节点
		// 判断条件为，当指针指向的下一个节点不为空（偶数节点）并且指针指向的下下个节点不为空（奇数节点）,两者不能交换，否则会导致指针异常
        while (pre->next != nullptr && pre->next->next != nullptr) {
            // pre cur post分别表示左、中、右三个节点，先保存好他们的节点信息，这样交换位置时不出错
            ListNode* cur = pre->next; 	
            ListNode* post = pre->next->next;

            cur->next = post->next; 
            post->next = cur;
            pre->next = post;
            /*
            pre->next = post;
            cur->next = post->next;
            post->next = cur;
            */

            pre = pre->next->next; // 每隔两个交换链表
        }
        return dummyHead->next; //返回的一定是虚拟头节点指向的下一个

    }
};

总结： 本题难在两个点判断条件和交换顺序

1. 判断条件，当指针指向的下一个节点不为空（偶数节点）并且指针指向的下下个节点不为空（奇数节点）,两者不能交换，否则会导致指针异常
2. 交换顺序，在交换的过程中，从后往前或者从前往后交换都可以，但是指向的时候一定要注意。

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

题目链接LC19
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

输入：head = [1], n = 1
输出：[]

思路：拿到题目发现是增删改查的删除节点，那么首先定义一个虚拟头节点。之后用双指针法，先让快指针走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 != nullptr) {
            fast = fast->next; // 快指针先走 n 步
        }

        while (fast->next != nullptr) { // 重点在这
            
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        return dummyhead->next;
    }
};

**总结：**本题的难点再于刚拿到题目容易想错，导致不知道从何下手。那么一旦想到双指针法，他们只要间隔 n 步，那么当快指针停止时，慢指针指向的就是倒数第 n 个链表节点，然后改变指向达到删除。

面试题 02.07. 链表相交

题目链接02.07
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
题目数据 保证 整个链式结构中不存在环。

思路：求两个链表交点节点的指针，交点不是数值相等，而是指针相等。

1. 先考虑链表长度相等时，我们可以直接遍历两个链表，当他们节点指针相同时，返回该节点即可
2. 当长度不相同的时候，我们就需要先让长度较长的移动两个的链表长度的差值，为了方便，我们始终让A链表当最长的链表。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        // m,n分别为A,B链表的长度
        int m = 0, n = 0;
        while (curA != NULL) {
            m++;
            curA = curA->next;
        }
        while (curB != NULL) {
            n++;
            curB = curB->next;
        }
        // 记录长度之后，再重头记录节点
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，n为其长度
        if (n > m) {
            swap(m, n);
            swap(curA, curB);
        }
        //求出长度差，移动差值步之后两链表长度相同
        int gap = m - n;
        while (gap--) {
            curA = curA->next;
        }
        // 同时移动，当出相交的时候，返回
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

总结：

1. 本题难度简单，主要要注意的是链表相同不是值相同，而是指针相同。
2. 最后同时移动的时候先做if判断，再移动值。（自己不细心造成的情况）

142.环形链表II

环形链表2LC142

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

思路：

1. 快慢双指针，快指针周两步，慢指针走一步，如果在环内，那么一定会相遇
2. 当有环以后，在快慢相遇点设置一个指针，在头节点设置一个指针，他们同时移动，当两个指针相遇一定是环的入口。（这里比较难想到，需要数学公式的推理）

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) {
                    if (index1 == index2) {
                        return index2;
                    }
                    index1 = index1->next;
                    index2 = index2->next;
                }
            }
        }
        return NULL;
    }
};

总结： 涉及的数学问题比较多，两个知识点比较难把握，但是做过以后就能够得到这种固定思路，还是比较容易的。

链表总结

• 链表的种类主要为：单链表，双链表，循环链表
• 链表的存储方式：链表的节点在内存中是分散存储的，通过指针连在一起。
• 链表是如何进行增删改查的。
• 数组和链表在不同场景下的性能分析。

虚拟头结点

在链表的增删改查中，设置虚拟头节点很有必要，每次对应头结点的情况都要单独处理，所以使用虚拟头结点的技巧，就可以解决这个问题。

反转链表

首先要知道迭代法是如何做到的，然后再去考虑递归法

删除倒数第N个节点

虚拟头结点 和 双指针法来移除链表倒数第N个节点。这里主要还是双指针法的应用。

链表相交

要注意链表相等是指针相等，不是值相等。

环形链表

需要多做类似的题目，才能更好掌握精髓。