我要评论24.两两交换链表中的节点
题目描述：
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例一:
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例二：
输入：head = [1]
输出：[1]
提示：
链表中节点的数目在范围 [0, 100] 内
0 <= node.val <= 100
解题思路：
- 关键词提取：交换两个相邻节点
- 暴力解法：
- 采用虚拟头节点的方式去操作链表
- 必须是两个相邻的节点，也就是单个节点不需要操作
- 需要搞清楚的是节点之间的关系，最好的方式还是画图来解决，否则节点的指针传递容易出错
- 由于需要交换两个节点，因此，需要将两个节点的next指针都储存起来，便于操作。节点t1储存节点1的next指针，节点t2储存节点2的next指针
- 节点cur储存虚拟头节点，节点pre储存节点cur的next指针，即节点1
- 让节点cur指向节点t1
- 让节点t1指向节点1，即节点pre
- 让节点1指向节点t2，即节点pre指向节点t2
- 一次节点交换就完成，若需要执行下一次节点交换，则需要将节点cur指向节点1，即节点pre
- 需要注意的是，交换发生的条件是节点1和节点2都不为空
代码如下：
/**
* 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) {}
* };
*/
class solution {
public:
listnode* swappairs(listnode* head) {
// 建立虚拟头节点
listnode* dummyhead = new listnode(0);
dummyhead->next = head;
// 建立一个遍历的虚拟头节点
listnode* curnode = dummyhead;
while(curnode->next != nullptr && curnode->next->next != nullptr) {
// 建立一个临时节点存储节点1
listnode* prenode = curnode->next;
// 建立两个临时节点存储节点1和节点2的next指针
listnode* tmp1node = prenode->next;
listnode* tmp2node = prenode->next->next;
// 虚拟头节点指向节点1的next指针
curnode->next = tmp1node;
// 节点2指向节点1
tmp1node->next = prenode;
// 节点1指向节点2的next指针
prenode->next = tmp2node;
// 移动虚拟头节点，至节点1
curnode = prenode;
}
// 返回链表的头节点
return dummyhead->next;
}
};
总结：
-
二刷，还是没有读懂题目，导致把题目想复杂，难以落笔，只好去看看题解。
1）难点一：两个节点交换，有三个next指针，容易指错对象，也容易导致程序bug。
2）难点二：两个节点交换的循环，退出条件是什么，这个很容易导致程序bug，也很难找出来原因。 -
代码随想录中提到的思路，让我二刷的时候清晰许多。
1）虚拟头节点的含义和用法。carl哥都讲解得很清晰。详见视频[https://www.bilibili.com/video/bv18b4y1s7r9/]:
2）画图。将各个节点以及节点的next指针都画出来。将储存next指针的节点也画出来。第一步取消掉next指针的指向，采用临时节点存起来。第二步再摆放节点位置。第三步就重新画next指针的指向。
3）尽管我多用了一个节点，但是这个是我思考之后，自己摸索出来的一个理解以后的方式。所以我没有按照carl哥的方式去解这道题。对于多用的pre节点，我的解释没有那么清晰，因为我对节点的理解还没有那么娴熟，也希望大家看完以后可以给我反馈，感谢。
19.删除链表的倒数第n个节点
题目描述：
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例一:
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例二：
输入：head = [1,2], n = 1
输出：[1]
提示：
链表中结点的数目为 sz
1 <= sz <= 30
0 <= node.val <= 100
1 <= n <= sz
解题思路：
-
关键词提取：删除、倒数第n个
-
暴力解法：
- 遍历一遍链表，记录节点个数size，由0开始计数
- 第二次再遍历链表，找到链表节点下标size-n-1，即待删除节点的前一个节点
- 采用临时节点存储下一个节点的next指针
- 当前节点指向临时节点
- 删除下一个节点
-
双指针法：
- 新建两个指针，左指针和右指针
- 倒数第n个数，假定n是两个指针之间的差值
- 当右指针指向最后一个节点时，左指针指向的节点，就是待删除节点的前一个节点
- 初始状态下，右指针指向头节点，左指针指向虚拟头节点
- 右指针开始移动，当右指针与左指针的差值超过n时，同步移动左指针
- 右指针移动到最后一个节点时，执行删除动作
- 采用临时节点储存左指针的next指针（即删除节点）
- 左指针指向临时节点的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) {}
* };
*/
class solution {
public:
listnode* removenthfromend(listnode* head, int n) {
// 建立虚拟头节点
listnode* dummyhead = new listnode(0);
dummyhead->next = head;
// 建立左右指针
int right = 0;
listnode* curnode = dummyhead->next;
int left = -1;
listnode* prenode = dummyhead;
// 遍历链表，直至右指针指向最后一个元素
while(curnode != nullptr && curnode->next != nullptr) {
// 右指针移动
curnode = curnode->next;
right++;
// 若右指针与左指针的距离超过n，左指针同步移动
if(right - left > n) {
left++;
prenode = prenode->next;
}
}
// 删除指定节点
listnode* tmpnode = prenode->next;
prenode->next = prenode->next->next;
// prenode->next->next = nullptr;
delete(tmpnode);
// 返回链表头节点
return dummyhead->next;
}
};
总结：
-
第一次做的时候，会采用暴力解法。
1）单向链表跟队列有点像。定位倒数第n个元素，可以做两次遍历解决。2）简单题就是删除第n个元素，只需要一次遍历即可。
-
代码随想录刷题中采用的是双指针法，稍微思考一下，可以联想到。
1）两次遍历，即两个for循环，可以想办法去降维，多用一个变量，左右指针从左右向中间靠拢，找到指定元素。
2）发现这道题跟滑动窗口有点像，左右指针构成一个窗口，窗口中是n+1个数，需要的是将最后一个节点囊括进来的窗口。取窗口的左边界辅助做删除节点的动作。
3）发现还能用栈去做，压栈、出栈，逻辑上有点类似。可以先将链表全部入栈，然后弹出n个元素，取最后一个弹出的元素，辅助做删除动作。
160.链表相交
题目描述：
给你两个单链表的头节点 heada 和 headb ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
示例一:
输入：intersectval = 8, lista = [4,1,8,4,5], listb = [5,0,1,8,4,5], skipa = 2, skipb = 3
输出：intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 a 为 [4,1,8,4,5]，链表 b 为 [5,0,1,8,4,5]。
在 a 中，相交节点前有 2 个节点；在 b 中，相交节点前有 3 个节点。
示例二：
输入：intersectval = 2, lista = [0,9,1,2,4], listb = [3,2,4], skipa = 3, skipb = 1
输出：intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 a 为 [0,9,1,2,4]，链表 b 为 [3,2,4]。
在 a 中，相交节点前有 3 个节点；在 b 中，相交节点前有 1 个节点。
提示：
lista 中节点数目为 m
listb 中节点数目为 n
0 <= m, n <= 3 * 104
1 <= node.val <= 105
0 <= skipa <= m
0 <= skipb <= n
如果 lista 和 listb 没有交点，intersectval 为 0
如果 lista 和 listb 有交点，intersectval == lista[skipa + 1] == listb[skipb + 1]
解题思路：
- 关键词提取：单链表、相交、起始节点
- 暴力法：两个for循环，一个负责遍历链表a，另一个负责嵌套遍历链表b，判断是否会出现链表a的某个节点与链表b的某个节点相同
- 暴力法优化：
- 关注相交节点的含义，是指链表a和链表b在起始相交节点后的节点长度与值都一致
- 找到链表的最后一个节点，看两个节点是否相等，即可判断是否有相交
- 由此可发现，相交的话，会跟最后一个节点有关系，那么有一个切入点是将两个链表的末端对齐，可以从后往前找，找到起始相交节点
- 第一步是计算出两个链表的长度
- 第二步是将两个链表的末端对齐，根据长度做差，遍历长链表，移动至差值位置，目的是让两个链表同步从头遍历
- 第三步是同步遍历两个链表，检索是否有相同的节点
代码如下：
/**
* definition for singly-linked list.
* struct listnode {
* int val;
* listnode *next;
* listnode(int x) : val(x), next(null) {}
* };
*/
class solution {
public:
listnode *getintersectionnode(listnode *heada, listnode *headb) {
listnode* dummyahead = new listnode(0);
dummyahead->next = heada;
listnode* dummybhead = new listnode(0);
dummybhead->next = headb;
listnode* curanode = dummyahead->next;
listnode* curbnode = dummybhead->next;
int lena = 0;
int lenb = 0;
// 检索链表a的长度
while(curanode != null && curanode->next != null) {
curanode = curanode->next;
lena++;
}
// 检索链表b的长度
while(curbnode != null && curbnode->next != null) {
curbnode = curbnode->next;
lenb++;
}
// 假如两个链表的最后一个节点不相等，意味着没有交点，若相等，则需要往前找到相交的起始位置
if(curanode != curbnode) {
return null;
}
// 定义两个链表的长度差值
int gap = 0;
// 将长度较长的链表定义为链表a
if(lena >= lenb) {
curanode = dummyahead->next;
curbnode = dummybhead->next;
gap = lena - lenb;
}
else {
curanode = dummybhead->next;
curbnode = dummyahead->next;
gap = lenb - lena;
}
// 链表a的遍历指针移动至gap值位置
// 链表a和链表b的末尾位置对齐
while(gap > 0) {
curanode = curanode->next;
gap--;
}
// 链表节点同时往后移动，找到相交点即可
while(curanode != null) {
if(curanode == curbnode) {
return curanode;
}
curanode = curanode->next;
curbnode = curbnode->next;
}
return null;
}
};
总结：
-
第一次做，还是老规矩，暴力解法。
1）难点是对于相交节点的定义不够清晰。会被误导成节点的值相等，导致无从下手。2）按照定义，就是两个嵌套的for循环，去找相同的节点。
-
代码随想录提供一个新的思路，就是针对相交，对暴力法做优化。
1）针对相交的这个定义，提供一个新的思路，就是将两个链表末端对齐，再从头开始同步遍历两个链表，直至找到相交的节点。
2）原理就是：在节点相交以后，之后的节点，都是一样的节点，也就是长度和值都相同。
142.环形链表ii
题目描述：
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例一:
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。
示例二：
输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。
提示：
链表中节点的数目范围在范围 [0, 104] 内
-105 <= node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引
解题思路：
- 关键词提取：某个节点可以再次到达（成环）
- 双指针法：
- 新建两个指针，快指针和慢指针
- 有一个算法原理是快慢指针，假如是成环的，那么一快一慢，快的那个在一定时间后，一定能追上慢的那个，也就是相遇
- 在确认快指针没有指向链表末尾，也就是不成环的情况下，快指针每次移动两个节点，而慢指针每次移动一个节点
- 在快慢指针相遇后，只能确认是成环，还需要找到入口
- 新建两个指针，指针1和指针2
- 有个数学计算结果是，在相遇时，采用指针1指向慢指针，采用指针2指向头指针，每次两个指针都移动一个节点，两个指针一定能相遇，这时，相遇点就是入口
快慢指针法代码如下：
/**
* 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 = head;
listnode* index2 = slow;
while(index1 != index2) {
index1 = index1->next;
index2 = index2->next;
}
return index1;
}
}
return null;
}
};
总结：
- 第一次做的时候，我做不出来，没什么思路。
- 代码随想录刷题中采用的是快慢指针法。
1）第一次看到的时候，还是蛮难去接受这个数学原理的，就是也不能算作算法的一种，但是的确又是一种很好的方法。通过两次刷题，将这个方法记住，这是我的现状。
2）官方题解会提供哈希表的方式，想了一下，的确，在检索重复元素方面，哈希表的确是个很好的方法。这点没有思考过，需要加强。
3）快慢指针，龟兔赛跑，找到相遇点，这个我可以理解，但是找到入口的这个部份，我理解得不是很好，为什么这个相遇，就是入口呢。希望可以有大佬给我提一些思路，感谢。
发表评论