LeetCode_Day4 | 好有难度的一个环形链表啊(在最后)！
LeetCode_链表
- 24. 两两交换链表中的节点
-
- 1.题目描述
- 2.虚拟头节点法
-
- 1.思路
- 2.代码实现
- 3.递归法
-
- 1.思路
- 2.代码实现
- 19. 删除链表的倒数第n个节点
-
- 1.题目描述
- 2.思路：双指针法
- 3.代码实现
- 面试题 02.07. 链表相交
-
- 1.题目描述
- 2.思路
- 3.代码实现
- 142. 环形链表 II
-
- 1. 题目描述
- 2.思路：快慢指针法
- 3.代码实现
24. 两两交换链表中的节点
1.题目描述
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例1：
示例2：
输入：head = []
输出：[]
输入：head = [1]
输出：[1]
详情leetcode链接
2.虚拟头节点法
1.思路
根据题意发现，两两交换节点实际上改变节点指针的指向方向。
需要注意： 由于单链表特性，交换两个节点时，需要知道第一个节点的前一个节点，所以设置一个虚拟头节点，这样头节点的交换操作也可以和其他节点交换操作一样了。
交换核心实现：假设链表为dummyhead->1->2->3->…
- 设置虚拟头节点为当前节点cur = dummyHead
- 第一步将当前节点指向节点2，即cur.next = cur.next.next;
- 第二步将节点2指向节点1，即cur.next.next = temp1;这里需要注意操作完第一步时，节点1会无法表示，所以需提前将节点1保存为临时节点temp1 = cur.next；
- 第三步将节点1指向节点3，即temp1.next = temp3;同样如上，节点3需提前保存为临时节点ListNode temp3 = cur.next.next.next;
- 此次交换后的链表为 dummyhead->2->1->3->…将当前节点cur向后移动两个位置，进行接下来的两个节点的交换，直至结束
- 循环边界条件：当节点个数为偶数时，cur.next == null时，交换结束；节点个数为奇数时，cur.next.next == null时，交换结束；
简单图解如下：
2.代码实现
/**
- Definition for singly-linked list.
- public class ListNode {
- int val;
- ListNode next;
- ListNode() {}
- ListNode(int val) { this.val = val; }
- ListNode(int val, ListNode next) { this.val = val; this.next = next; }
- }
*/
class Solution {
/**
* 思路：使用虚拟头节点法
* 根据题意发现，两两交换节点实际上改变节点指针的指向方向。
*
* 需要注意：由于单链表特性，交换两个节点时，需要知道第一个节点的前一个节点
* 所以设置一个虚拟头节点，这样头节点的交换操作也可以和其他节点交换操作
* 一样了。
*
* 交换核心实现：假设链表为dummyhead->1->2->3->.....
* 1）设置虚拟头节点为当前节点cur = dummyHead
* 2）第一步将当前节点指向节点2，即cur.next = cur.next.next;
* 3）第二步将节点2指向节点1，即cur.next.next = temp1;这里需要注
* 操作完第一步时，节点1会无法表示，所以需提前将节点1保存为临时
* 节点temp1 = cur.next；
* 4）第三步将节点1指向节点3，即temp1.next = temp3;同样如上，节点3需提前
* 保存为临时节点ListNode temp3 = cur.next.next.next;
* 5）此次交换后的链表为 dummyhead->2->1->3->.....将当前节点cur向后移动
* 两个位置，进行接下来的两个节点的交换
* 6）当节点个数为偶数时，cur.next == null时，交换结束；节点个数为奇数
* 时，cur.next.next == null时，交换结束；
* 时间复杂度O(n)
* 空间复杂度O(1)
*/
public ListNode swapPairs(ListNode head) {
ListNode dummyHead = new ListNode(-1,head);// 设置一个虚拟头结点
ListNode cur = dummyHead;
while (cur.next != null && cur.next.next != null){
// 临时节点，保存两个节点之中的第一个节点
ListNode temp1 = cur.next;
//临时节点，保存两个节点后面的节点
ListNode temp3 = cur.next.next.next;
cur.next = cur.next.next;//交换步骤1
cur.next.next = temp1;//交换步骤2
temp1.next = temp3;//交换步骤3
cur = cur.next.next;//cur移动，准备下一轮交换
}
return dummyHead.next;
}
}
3.递归法
1.思路
- 递归的终止条件是链表中没有节点，或者链表中只有一个节点，此时无法进行交换。
- 如果链表中至少有两个节点，则在两两交换链表中的节点之后，原始链表的头节点变成新的链表的第二个节点，原始链表的第二个节点变成新的链表的头节点。
- 链表中的其余节点的两两交换可以递归地实现。在对链表中的其余节点递归地两两交换之后，更新节点之间的指针关系，即可完成整个链表的两两交换。
- 用 head 表示原始链表的头节点，新的链表的第二个节点用 newHead 表示新的链表的头节点即原始链表的第二个节点；
- 则原始链表中的其余节点的头节点是 newHead.next。令 head.next = swapPairs(newHead.next)，表示将其余节点进行两两交换，
- 交换后的新的头节点为 head 的下一个节点。然后令 newHead.next = head，即完成了所有节点的交换。最后返回新的链表的头节点 newHead。
简单图解如下：
2.代码实现
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
/**
* 思路：递归法
* 递归的终止条件是链表中没有节点，或者链表中只有一个节点，此时无法进行交换。
* 如果链表中至少有两个节点，则在两两交换链表中的节点之后，原始链表的头节点变成新的链表的第二个节点，原始链表的第二个节点变成新的链表的头节点。
* 链表中的其余节点的两两交换可以递归地实现。在对链表中的其余节点递归地两两交换之后，更新节点之间的指针关系，即可完成整个链表的两两交换。
* 用 head 表示原始链表的头节点，新的链表的第二个节点用 newHead 表示新的链表的头节点即原始链表的第二个节点；
* 则原始链表中的其余节点的头节点是 newHead.next。令 head.next = swapPairs(newHead.next)，表示将其余节点进行两两交换，
* 交换后的新的头节点为 head 的下一个节点。然后令 newHead.next = head，即完成了所有节点的交换。最后返回新的链表的头节点 newHead。
* 时间复杂度O(n)
* 空间复杂度O(n)：递归次数*每次的操作数；
*/
public ListNode swapPairs(ListNode head) {
//递归的终止条件
if (head == null || head.next == null){
return head;
}
//交换后的新的头节点
ListNode newHead = head.next;
//相当于交换头节点将原头节点指向下一轮交换的头节点
head.next = swapPairs(newHead.next);
//将新头节点指向原头节点
newHead.next = head;
//返回新头节点
return newHead;
}
}
19. 删除链表的倒数第n个节点
1.题目描述
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例：
输入：head = [1], n = 1
输出：[]
输入：head = [1,2], n = 1
输出：[1]
详情leetcode链接
2.思路：双指针法
双指针法： 本题最难的点在于如何定位到“倒数第n个节点”，所以利用快慢指针的固定位置差就可以定位到要删除节点的位置了。
- 首先初始时让fast和slow同时指向虚拟头节点(使用虚拟头节点避免需要特殊考虑头节点的处理)，然后让fast先移动n位(即和slow制造出n个差值)
- 然后fast和slow同时向后不断移动，直至fast指向最后一个节点(即fast.next == null)时不再移动，此时slow指向的是要删除元素的前一个元素(因为单链表特性，如果要删除第n个节点，需要知道其前边的一个节点)
- 最后将要删除元素的前一个元素直接指向要要删除元素的下一个元素。即slowIndex.next = slowIndex.next.next;
简单图解如下：
3.代码实现
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
/**
* 思路：双指针法
* 本题最难的点在于如何定位到“倒数第n个节点”，所以利用快慢指针的固定位置差就可以定位到要删除节点的位置了。
* 首先初始时让fast和slow同时指向虚拟头节点(使用虚拟头节点避免需要特殊考虑头节点的处理)，然后让fast先移动n位(即和slow制造出n个差值)
* 然后fast和slow同时向后不断移动，直至fast指向最后一个节点(即fast.next == null)时不再移动，此时slow指向的是要删除元素的前一个元素(因为单链表特性，如果要删除第n个节点，需要知道其前边的一个节点)
* 最后将要删除元素的前一个元素直接指向要要删除元素的下一个元素。即slowIndex.next = slowIndex.next.next;
* 时间复杂度：O(n),为n链表的长度
* 空间复杂度：O(1)
*/
public ListNode removeNthFromEnd(ListNode head, int n) {
//定义虚拟头节点
ListNode dummyHead = new ListNode(0,head);
//定义快慢指针
ListNode fast = dummyHead;
ListNode slow = dummyHead;
//先将fast移动n位，制造固定差
for (int i = 0; i < n; i++){
fast = fast.next;
}
//同时移动快慢指针，直至fast指向最后一个节点，此时slow指向要删除节点的前一个节点。
while (fast.next != null){
fast = fast.next;
slow = slow.next;
}
//删除倒数第n个节点
slow.next = slow.next.next;
return dummyHead.next;
}
}
面试题 02.07. 链表相交
1.题目描述
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。注意，函数返回结果后，链表必须 保持其原始结构 。
示例1：
输入：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 个节点。
示例2：
输入：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 个节点。
示例3：
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。
提示：
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]
详情leetcode链接
2.思路
简单来说就是求两个链表交点节点的指针。 但需注意交点不是数值相等，而是指针相等。
- 利用双指针，定义链表A指针节点curA,链表B的节点curB，两个指针需要同时遍历链表，
- 但由于两个链表长度不一定相等，所以需要先将指针curA移动到，和curB末尾对齐的位置；此时开始比较：
如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。否则循环退出返回空指针。
简单图解如下：
3.代码实现
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
/**
* 思路：双指针法
* 求两个链表交点节点的指针。(注意交点不是数值相等，而是指针相等)
* 利用双指针，定义链表A指针节点curA,链表B的节点curB，两个指针需要同时遍历
* 链表，但由于两个链表长度不一定相等，所以需要先将指针curA移动到，和curB
* 末尾对齐的位置；此时开始比较：
* 如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。
* 否则循环退出返回空指针。
* 时间复杂度：O(m+n)
* 空间复杂度：O(1)
*/
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode curA = headA;
ListNode curB = headB;
int lengthA = 0;
int lengthB = 0;
//求headA的长度
while (curA != null){
curA = curA.next;
lengthA++;
}
//求headB的长度
while (curB != null){
curB = curB.next;
lengthB++;
}
curA = headA;
curB = headB;
// 让curA为最长链表的头，lenA为其长度
if (lengthB > lengthA){
//1. swap (lenA, lenB);
int tempLength = lengthB;
lengthB = lengthA;
lengthA = tempLength;
//2. swap (curA,curB)
ListNode tempNode = curB;
curB = curA;
curA = tempNode;
}
int gap = lengthA - lengthB;
//让curA和curB在同一起点上（末尾位置对齐）
while (gap-- > 0){
curA = curA.next;
}
//遍历curA 和 curB，遇到相同则直接返回
while (curA != null){
if (curA == curB){
return curA;
}
curA = curA.next;
curB = curB.next;
}
return null;
}
}
142. 环形链表 II
1. 题目描述
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例1：
示例2：
示例3：
提示：
链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引
详情leetcode链接
2.思路：快慢指针法
本题的难点在于：判断链表是否有环、如何找到环入口
快慢指针想法来源： 一个稳定以快速度指针和一个稳定慢速度指针在圈内终会相遇
-
分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和
slow指针在途中相遇 ，说明这个链表有环。 -
为什么在环中一定相遇： 因为fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。
-
如果有环即相遇了，假设从头结点到环形入口节点 的节点数为x。，环形入口节点到 fast指针与slow指针相遇节点 节点数为y。从相遇节点 再到环形入口节点节点数为 z；
-
相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。
-
因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：(x + y) * 2 = x + y + n (y + z)，化简x + y = n (y + z)
-
因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离，x = n (y + z) - y ,
-
再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z， 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。
-
先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了，当 n为1的时候，公式就化解为 x = z。
-
这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。
-
也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2，让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。
-
如果大于1是什么情况呢，就是fast指针在环形转n圈之后才遇到 slow指针。
-
这种情况和n为1的时候 效果是一样的，一样可以通过这个方法找到 环形的入口节点，只不过，index1 指针在环里 多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。
记录下图解笔记(有点乱，待整理)：
3.代码实现
/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
/**
* 做题前需思考的问题：判断链表是否有环、如何找到环入口
* 思路：快慢指针法
* 快慢指针想法来源：一个稳定以快速度指针和一个稳定慢速度指针在圈内终会相遇
* 分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。
* 解释：为什么在环中一定相遇：因为fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。
* 如果有环即相遇了，假设从头结点到环形入口节点 的节点数为x。，环形入口节点到 fast指针与slow指针相遇节点 节点数为y。，从相遇节点 再到环形入口节点节点数为 z；
* 相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。
* 因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：(x + y) * 2 = x + y + n (y + z)，化简x + y = n (y + z)
* 因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离，x = n (y + z) - y ,
* 再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。
* 先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了，当 n为1的时候，公式就化解为 x = z。
* 这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。
* 也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2，让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。
* n如果大于1是什么情况呢，就是fast指针在环形转n圈之后才遇到 slow指针。
* 这种情况和n为1的时候 效果是一样的，一样可以通过这个方法找到 环形的入口节点，只不过，index1 指针在环里 多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。
* 时间复杂度: O(n)，快慢指针相遇前，指针走的次数小于链表长度，快慢指针相遇后，两个index指针走的次数也小于链表长度，总体为走的次数小于 2n
* 空间复杂度: O(1)
*
*/
public ListNode detectCycle(ListNode head) {
ListNode slow = head;
ListNode fast = 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 index1;
}
}
return null;
}
}