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

合集 - 代码随想录算法训练营(38)

1.代码随想录算法训练营第1天| 704. 二分查找、27. 移除元素、977.有序数组的平方01-222.代码随想录算法训练营第2天|209. 长度最小的子数组、59.螺旋矩阵II01-233.代码随想录算法训练营第3天|203.移除链表元素、707.设计链表、206.反转链表01-24

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

5.代码随想录算法训练营第5天|242.有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和01-276.代码随想录算法训练营第6天|454.四数相加II、383. 赎金信、15. 三数之和、18. 四数之和02-037.代码随想录算法训练营第7天|344.反转字符串、541. 反转字符串II、替换数字、151.翻转字符串里的单词02-048.代码随想录算法训练营第8天|右旋转字符串、28. 实现 strStr()、459.重复的子字符串02-059.代码随想录算法训练营第9天|232.用栈实现队列、225. 用队列实现栈、20. 有效的括号、1047. 删除字符串中的所有相邻重复项02-0610.代码随想录算法训练营第10天|150. 逆波兰表达式求值、239. 滑动窗口最大值、347.前 K 个高频元素02-0711.代码随想录算法训练营第11天|二叉树理论基础、二叉树的递归遍历、二叉树的迭代遍历、二叉树的层序遍历02-0812.代码随想录算法训练营第12天|226. 翻转二叉树、101. 对称二叉树、104.二叉树的最大深度、111.二叉树的最小深度02-1013.代码随想录算法训练营第13天|222.完全二叉树的结点个数、110.平衡二叉树、257.二叉树的所有路径、404.左叶子之和02-1114.代码随想录算法训练营第14天|513.找树左下角的值、112.路径总和、106.从中序与后序遍历序列构造二叉树02-1215.代码随想录算法训练营第15天|654.最大二叉树、617. 合并二叉树、700.二叉搜索树中的搜索、98. 验证二叉搜索树02-1316.代码随想录算法训练营第16天|530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先02-1517.代码随想录算法训练营第17天|235. 二叉搜索树的最近公共祖先、701. 二叉搜索树中的插入操作、450. 删除二叉搜索树中的节点02-1618.代码随想录算法训练营第18天|669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538. 把二叉搜索树转换为累加树02-1719.代码随想录算法训练营第19天|回溯算法理论基础、77. 组合、组合优化、216.组合总和III、17.电话号码的字母组合02-1920.代码随想录算法训练营第20天|39. 组合总和、40.组合总和II、131.分割回文串02-2021.代码随想录算法训练营第21天|93.复原IP地址、78. 子集、90.子集II02-2122.代码随想录算法训练营22天|491.非递减子序列、46.全排列、47.全排列 II02-2223.代码随想录算法训练营第23天|455.分发饼干、376. 摆动序列、53. 最大子数组和02-2324.代码随想录算法训练营第24天|122.买卖股票的最佳时机 II、55. 跳跃游戏、45.跳跃游戏 II、1005. K 次取反后最大化的数组和02-2425.代码随想录算法训练营第25天|134. 加油站、135. 分发糖果、860.柠檬水找零、406. 根据身高重建队列02-2526.代码随想录算法训练营第26天|452. 用最少数量的箭引爆气球、435. 无重叠区间、763.划分字母区间02-2627.代码随想录算法训练营第27天|56. 合并区间、738.单调递增的数字02-2728.代码随想录算法训练营第28天|动态规划理论基础、509. 斐波那契数、70. 爬楼梯、746. 使用最小花费爬楼梯02-2829.代码随想录算法训练营第29天|62.不同路径、63. 不同路径 II03-0130.代码随想录算法训练营第30天|动态规划：01背包理论基础、卡玛网46、动态规划：01背包理论基础（滚动数组）、416. 分割等和子集03-0331.代码随想录算法训练营第31天|1049.最后一块石头的重量II、494.目标和、474.一和零03-0432.代码随想录算法训练营第32天|完全背包理论基础-二维DP数组、518.零钱兑换II、377. 组合总和 Ⅳ、57. 爬楼梯（进阶版）03-0533.代码随想录算法训练营第33天|322. 零钱兑换、279.完全平方数、139.单词拆分03-0634.代码随想录算法训练营第34天|198.打家劫舍、213.打家劫舍II、337.打家劫舍 III03-0735.代码随想录算法训练营第35天|121. 买卖股票的最佳时机、122.买卖股票的最佳时机II、123.买卖股票的最佳时机III03-0836.代码随想录算法训练营第36天|188.买卖股票的最佳时机IV、309.最佳买卖股票时机含冷冻期、714.买卖股票的最佳时机含手续费03-0937.代码随想录算法训练营第37天|300.最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组03-1038.代码随想录算法训练营第38天|1143.最长公共子序列、1035.不相交的线、53. 最大子数组和、392.判断子序列03-12

收起

LeetCode24

2025-01-25 15:05:55 星期六

题目描述：力扣24
文档讲解：代码随想录(programmercarl)24.两两交换链表中的节点
视频讲解：《代码随想录》算法视频公开课：帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点

代码随想录视频内容简记

用虚拟头结点的方式来做

梳理

上图中蓝线表示的执行的反转操作，红色序号表示的每一步反转操作导致消失的的指针

1. while的循环条件

2. 反转操作

3. 设置两个tmp临时的指针为了循环往下遍历

大致代码内容

1. while (cur->next != NULL && cur->next->next != NULL)，，前一个是在链表有偶数个结点的情况，后一个是链表有奇数个结点的情况。这个条件一定不能写反，因为一旦反过来写，如果cur->next为空指针，那么cur->next->next就相当于操作空指针了

2. 反转操作

---

tmp = cur->next;
tmp1 = cur->next->next->next;
cur->next = cur->next->next;
cur->next->next = tmp;
cur->next->next->next = tmp1;

3. 因为为了避免链表结点反转时出现对空指针的操作，所以要设置两个temp指针

LeetCode测试

代码比较好通过

点击查看代码

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* cur = dummyHead;
        ListNode* tmp;
        ListNode* tmp1;
        while (cur->next != NULL && cur->next->next != NULL) {
            // 交换结点
            tmp = cur->next;
            tmp1 = cur->next->next->next;
            cur->next = cur->next->next;
            cur->next->next = tmp;
            cur->next->next->next = tmp1;
            // 指针后移
            cur = cur->next->next;
        }
        return dummyHead->next;
    }
};

LeetCode19

题目描述：力扣19
文档讲解：代码随想录(programmercarl)19.删除链表的倒数第N个节点
视频讲解：《代码随想录》算法视频公开课：链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点

代码随想录视频内容简记

这道题仍然使用的是双指针的思想，一个快指针和一个满指针，和27.移除元素很相近，但是这道题目巧妙的地方在于先让快指针移动n+1步，之后快慢指针同时移动直到快指针为空。

梳理

1. 首先是定义虚拟头结点，以及对快慢指针的定义

2. 第一个while循环控制先让快指针移动n+1步。如上图，我们确实需要删除slow指针为倒数n=2的结点，但是就因为如此，才需要移动该位置的前驱结点，来对其进行删除。也就是slow需要少移动一个位置，而fast需要多移动一个位置，移到红框所指的实箭头处。

3. 第二个while循环控制再让快慢指针同时移动

4. 删除结点

大致代码内容

1. 快指针先移动。首先进行n++操作，之后进行while (n-- && fast != NULL)

---

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

2. 两个指针同时移动

---

while (fast != NULL) {
	fast = fast->next;
	slow = slow->next;
}

LeetCode测试

代码比较好通过，就是不要总是忘了dummyHead->next = head，要不然总会报空指针的错误。

点击查看代码

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

面试题 02.07. 链表相交

题目描述：力扣面试题 02.07. 链表相交
文档讲解：代码随想录(programmercarl)面试题 02.07. 链表相交

内容梳理

1. 这个在王道书上见过，之要判断只要中间有一个指针是相同的，那么其后的部分就一定相交，因为指针所指的地址肯定是一样的。因为链表的长度不一样，所以要先在长链表上遍历两个链表之间长度的差

2. 核心还是双指针的思想，一个负责A链表，一个负责B链表

LeetCode测试

这个题还是有几点值得注意的

1. 那就是指针相等$\neq$数值相等。可以看力扣在题目描述中给出的示例1

刚开始我也很疑惑，为什么不是从1开始的。后来看评论区，这是是假设了一种可能，也就是curA指向的1和curB指向的1的地址不一样，但是二者所指向的8的地址是一样的。所以在判断是就要用if (curA == curB)来直接进行判断，而不是if (curA->val == curB->val)

2. 注意这个循环遍历的终止条件的书写，因为题目要求“如果两个链表没有交点，返回 null”，所以while循环中要同时给出两个情况的return

---

while (curA != NULL) {
	if (curA == curB) return curA;
	...
}
return NULL;

链表相交完整代码

点击查看代码

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

LeetCode142

题目描述：力扣142
文档讲解：代码随想录(programmercarl)142.环形链表II
视频讲解：《代码随想录》算法视频公开课：把环形链表讲清楚！| LeetCode:142.环形链表II

代码随想录视频简记

梳理

1. 判断是否有环

   首先是一个快指针，一个慢指针，如果两个指针能出现相等的情况，那说明这个链表一定有环。
   但是如何保证不出现快指针把满指针正好跳过的情况呢？，这里就需要对二者的移动速度进行特殊定义，也就是快指针每次移动两个位置，慢指针每次移动一个位置。这样快指针每次相对于慢指针的移动位数就是1，那么以1个相对位置的距离靠近，就可以保证中间没有跳过。

还有一点就是，注意二者的相遇并不是追及，从动图中可以看出来，快指针中间追上了慢指针，但是仍然会往前走一个距离，而等慢指针再走一个距离。也就是无论是fast还是slow指针，其next操作必须走完才行

2. 确定环的入口

   这里需要做一些简单的数学推导

   我们假设慢指针首先走过了$x+y$，而快指针因为在圈内绕过了$n$圈，所以快指针走过了$x+y+n\cdot (y+z)$，而因为二者的速度差异，即快指针是慢指针的速度二倍。所以可列出下面的等式

$$\begin{align} 2\cdot (x+y) &= x+y+n\cdot (y+z)\notag \\ x+y&=n\cdot (y+z) \notag \\ x &=n\cdot (y+z) - y \notag \\ x &=(n-1)\cdot (y+z)+z \notag \end{align}$$

由此，我们便得到了关键的公式。我们可以代入特殊值$n=1$发现，$x=z$，也就是说无论快指针在环内转了多少圈，$x$的距离等于$n-1$圈加上$z$的距离。

那么如果定义一个index1指针指向两个指针相遇的地方，一个index2指向头结点，那么两个指针同时移动，最终相等的地方就是环的入口

---

这里还有一个问题就是K哥讲到的，为什么慢指针走过的距离不能是$x+y+k\cdot (y+z)$？，就是为什么慢指针在走完第一圈的时候就一定会被快指针追上呢？

可以看到，慢指针从入口进入，在走完第一圈的时候，快指针会以二倍慢指针的速度超过他，所以一定会在慢指针走完第一圈的时候追上慢指针

大致代码内容

注意代码中仍然是指针与指针相等，并不是指针的val

---

while (fast != NULL && fast->next != NULL) {
	fast = fast->next->next;
	slow = slow->next;
	if (fast == slow) {
		index1 = fast;
		index2 = head;
		while (index1 != index2) {
			index1 = index1->next;
			index2 = index2->next;
		}
		return index1;
	}
}
return NULL;

还有就是为什么需要while (fast != NULL && fast->next != NULL)，因为我们需要保证fast = fast->next->next是有意义的，如果fast->next = NULL，那么NULL->next就显然没有意义了。

按照k哥的说法

这么做是为了放心大胆的进行fast = fast->next->next

LeetCode测试

关于时间复杂度

关于代码的时间复杂度，文档中是这么写的，在快慢指针相遇前，快慢指针的元素的平均操作次数小于链表长度n，所以时间度复杂度为$O(n)$，在相遇之后，index1和index2指针对元素的平均操作操作长度也小于链表长度n，所以时间复杂度也为$O(n)$，最终的时间复杂度就为$O(n)$

环形链表Ⅱ完整代码如下

点击查看代码

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