代码随想录第四天(链表~)
目录
今日学习的文章
两两交换链表中的节点
看到题目的第一想法
看到代码随想录之后的想法
自己实现过程中遇到的困难
删除链表的倒数第N个节点
看到题目的第一想法
看到代码随想录之后的想法
自己实现过程中遇到的困难
面试题 02.07. 链表相交
看到题目的第一想法
看到代码随想录之后的想法
自己实现过程中遇到的困难
142.环形链表II
看到题目的第一想法
看到代码随想录之后的想法
自己实现过程中遇到的困难
今日学习的文章
写代码的时候最好对照图像的逻辑来写，可以画个图，模拟，不会太乱
两两交换链表中的节点
用虚拟头结点，这样会方便很多。
本题链表操作就比较复杂了，建议大家先看视频，视频里我讲解了注意事项，为什么需要temp保存临时节点。
题目链接/文章讲解/视频讲解： 代码随想录
看到题目的第一想法
这道题的目标时要将链表中的节点，每两个两个进行交换，我看到题目第一时间选择画图，以及回忆了之前链表反转的代码，但是在控制指针时还是容易乱
看到代码随想录之后的想法
1.设置头节点:卡哥视频中的关键所在，如果要操作两个节点的反转，必须cur节点要在这两个节点之前才方便操作，相当于用一个前置节点操作它的 后置节点和后置的后置节点 之间的反转
2.需要考虑while循环的终止条件，到链表最后，奇数时候，cur.next.next为null,偶数时候cur.next为null
3.cur指向的位置相当关键，同时还需要设置临时变量
自己实现过程中遇到的困难
1.设置头节点:卡哥视频中的关键所在，如果要操作两个节点的反转，必须cur节点要在这两个节点之前才方便操作，相当于用一个前置节点操作它的 后置节点和后置的后置节点 之间的反转
2.需要考虑while循环的终止条件，到链表最后，奇数时候，cur.next.next为null,偶数时候cur.next为null
3.cur指向的位置相当关键，同时还需要设置临时变量，一个用来定位前一个节点，一个用来连接后续的节点
/**
* 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 {
public ListNode swapPairs(ListNode head) {
//两两交换，需要框起来？
//设置头节点:卡哥视频中的关键所在，如果要操作两个节点的反转，必须cur节点要在这两个节点之前才方便操作
//相当于用一个前置节点操作它的 后置节点和后置的后置节点 之间的反转
//cur->[反转1]-->[反转2]
//需要考虑while循环的终止条件，到链表最后，奇数时候，cur.next.next为null,偶数时候cur.next为null
ListNode newHead = new ListNode();
newHead.next = head;
ListNode cur = newHead;
ListNode temp = new ListNode();
ListNode temp1 = new ListNode();
while(cur.next!=null&&cur.next.next!=null){
temp = cur.next;
//下一个要反转的目标
temp1 = cur.next.next.next;
//前置节点指向后置的后置
cur.next = cur.next.next;
//后置节点的反转
cur.next.next = temp;
cur = temp;
cur.next = temp1;
}
return newHead.next;
}
}
删除链表的倒数第N个节点
双指针的操作，要注意，删除第N个节点，那么我们当前遍历的指针一定要指向 第N个节点的前一个节点，建议先看视频。
题目链接/文章讲解/视频讲解：代码随想录
看到题目的第一想法
用暴力or堆栈，没想到卡哥的方法
看到代码随想录之后的想法
还是经典的双指针，快指针走了n+1步之后慢指针再开始同步走(为什么是n+1，因为删除节点需要在该节点之前才能删除该节点，所以快指针比慢指针快n+1)
自己实现过程中遇到的困难
1快指针应该要走多少步？n+1步 因为slow要指向倒数第n个元素的前一个，所以fast要比slow快n+1
2需要添加虚拟头节点，开始时快慢指针都是指向头节点，删除的是slow的下一个节点
3while循环中的条件为fast！=null
我自己实现的时候while循环考虑的是 fast.next!=null
1 这时快指针只需要走n步，也是可行的
2 因为快指针走到最后时不会走到null，而是走到最后一个元素来终止循环
例如:删除倒数第一个时，fast会指向倒数第一个元素，而slow会指向倒数第一个节点的前一个节点，其他的也可以这样考虑
/**
* 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 {
public ListNode removeNthFromEnd(ListNode head, int n) {
//暴力解法，遍历总长度，算出总长度-n
//使用栈找到倒数第N-1个
//卡哥思路：双指针，一个快指针先走n步，慢指针再开始走
//快指针应该要走多少步？n+1步 因为slow要指向倒数第n个元素的前一个，所以fast要比slow快1
//需要添加虚拟头节点，开始时快慢指针都是指向头节点，删除的是slow的下一个节点
//while循环中的条件为fast！=null
ListNode newHead= new ListNode();
newHead.next = head;
ListNode fastIndex = newHead;
ListNode slowIndex = newHead;
//fast先走
for(int i=0;i面试题 02.07. 链表相交
本题没有视频讲解，大家注意 数值相同，不代表指针相同。
题目链接/文章讲解：代码随想录
看到题目的第一想法
计算出两个链表的长度再相减，然后再用双指针走
看到代码随想录之后的想法
计算出两个链表的长度再相减得到offset，再通过长的先走完offset后，同步往下走
自己实现过程中遇到的困难
1 中间考虑到时用元素的值相等来判断是否相遇，其实是错误的，正确的方式应该是用元素的地址相等来判断是否相遇
2 该题是判断重合的点在哪，所以两个链表长度需要规划为相等的，才能逐步进行判断，我写的时候差点误把长度相等的点(就是走了offset位后两个链表长度相同的起始点)视为了重合点了
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
//先走到最后，看两个链表长度的大小
//然后根据差值，长的先走，慢的再走
ListNode listNodeA = headA;
ListNode listNodeB = headB;
int countA=0;
int countB=0;
while(listNodeA!=null)
{
countA++;
listNodeA = listNodeA.next;
}
while(listNodeB!=null){
countB++;
listNodeB = listNodeB.next;
}
//相等不需要特殊处理，而是一起往下走
/*if(countA==countB){
if(headA == headB){
return headA;
}else{
return null;
}
}*/
listNodeA = headA;
listNodeB = headB;
int offset = countA>countB?countA-countB:countB-countA;
//根据差值，A先走offset
for(int i = 0;icountB){
listNodeA = listNodeA.next;
}
}
//然后再一起走
while(listNodeA!=null&&listNodeB!=null){
//不能用值相等来判断，要用节点相等来判断
if(listNodeA==listNodeB){
return listNodeA;
}
listNodeA = listNodeA.next;
listNodeB = listNodeB.next;
}
return null;
}
} 142.环形链表II
算是链表比较有难度的题目，需要多花点时间理解 确定环和找环入口，建议先看视频。
题目链接/文章讲解/视频讲解：代码随想录
看到题目的第一想法
通过双指针来判断是否有环，一个每次走两个，一个每次走一个，但是不太确定这个方法是否是对的，不知道两个指针会不会在环里相遇
找起始点没想到方法
看到代码随想录之后的想法
1 如何检测链表有环 双指针？
2 第一个走一次，第二个指针走两次会相遇吗？因为快指针相当于每次以一个节点的速度去靠近慢指针，所以他们一定会相遇
3 当慢指针进入环的时候，快指针总会在慢指针走一圈没走完时追上慢指针?
因为快指针是慢指针的两倍速度，当满指针走完一圈时，快指针走了两圈了(快指针一定能追上慢指针)
4 快慢指针交汇点有相关的数学证明
起点走到入口为X，快指针在环里遇到慢指针为Y，Y到X的距离为Z
慢指针走了(X+Y) 快指针走了(Y+Z)n+X+Y = 2(X+Y)==>(X+Y) = n(Y+Z)==>(X+Y)=(n-1)(Y+Z)+Z+Y=>X=(n-1)(Y+Z)+Z==>
X=Z+(n-1)(Y+Z) Y+Z都可以视为走的圈数而已
当Z从起点出发到交汇点，X也从起点出发到交汇点,两者最终会在环的起点相遇
则当Z走向交汇点时，X也走向交汇点
自己实现过程中遇到的困难
1 如何检测链表有环 双指针？
2 第一个走一次，第二个指针走两次会相遇吗？因为快指针相当于每次以一个节点的速度去靠近慢指针，所以他们一定会相遇
3 当慢指针进入环的时候，快指针总会在慢指针走一圈没走完时追上慢指针?
因为快指针是慢指针的两倍速度，当满指针走完一圈时，快指针走了两圈了(快指针一定能追上慢指针)
4 快慢指针交汇点有相关的数学证明
起点走到入口为X，快指针在环里遇到慢指针为Y，Y到X的距离为Z
慢指针走了(X+Y) 快指针走了(Y+Z)n+X+Y = 2(X+Y)==>(X+Y) = n(Y+Z)==>
这里让出一个(Y+Z) 也就是一圈
(X+Y)=(n-1)(Y+Z)+Z+Y=>X=(n-1)(Y+Z)+Z==>
X=Z+(n-1)(Y+Z) Y+Z都可以视为走的圈数而已 当n=1时X=Z
当Z从起点出发到交汇点，X也从起点出发到交汇点,两者最终会在环的起点相遇
则当Z走向交汇点时，X也走向交汇点
我自己写的方法复杂了一点(注释中的方法)，其实可以简单点，把找起点的操作就放在while循环中，最后统一返回null
/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
/*public class Solution {
public ListNode detectCycle(ListNode head) {
//如何检测链表有环 双指针？
//第一个走一次，第二个指针走两次？因为快指针相当于每次以一个节点的速度去靠近慢指针，所以他们一定会相遇
//当慢指针进入环的时候，快指针总会在慢指针走一圈没走完时追上慢指针
//因为快指针是慢指针的两倍速度，当满指针走完一圈时，快指针走了两圈了(快指针一定能追上慢指针)
//起点走到入口为X，快指针在环里遇到慢指针为Y，Y到X的距离为Z
//慢指针走了(X+Y) 快指针走了(Y+Z)n+X+Y = 2(X+Y)==>(X+Y) = n(Y+Z)==>(X+Y)=(n-1)(Y+Z)+Z+Y=>X=(n-1)(Y+Z)+Z==>
// X=Z+(n-1)(Y+Z) Y+Z都可以视为走的圈数而已
//当Z从起点出发到交汇点，X也从起点出发到交汇点,两者最终会在环的起点相遇
//则当Z走向交汇点时，X也走向交汇点
ListNode slowIndex = head;
ListNode fastIndex = head;
if(head==null){
return null;
}
while(fastIndex!=null&&fastIndex.next!=null){
fastIndex = fastIndex.next.next;
slowIndex = slowIndex.next;
if(fastIndex==slowIndex){
break;
}
}
if(fastIndex==null||fastIndex.next==null){
return null;
}
ListNode headIndex = head;
while(headIndex!=fastIndex){
headIndex = headIndex.next;
fastIndex = fastIndex.next;
}
return headIndex;
}
}*/
public class Solution {
public ListNode detectCycle(ListNode head) {
//如何检测链表有环 双指针？
//第一个走一次，第二个指针走两次？因为快指针相当于每次以一个节点的速度去靠近慢指针，所以他们一定会相遇
//当慢指针进入环的时候，快指针总会在慢指针走一圈没走完时追上慢指针
//因为快指针是慢指针的两倍速度，当满指针走完一圈时，快指针走了两圈了(快指针一定能追上慢指针)
//起点走到入口为X，快指针在环里遇到慢指针为Y，Y到X的距离为Z
//慢指针走了(X+Y) 快指针走了(Y+Z)n+X+Y = 2(X+Y)==>(X+Y) = n(Y+Z)==>(X+Y)=(n-1)(Y+Z)+Z+Y=>X=(n-1)(Y+Z)+Z==>
// X=Z+(n-1)(Y+Z) Y+Z都可以视为走的圈数而已
//当Z从起点出发到交汇点，X也从起点出发到交汇点,两者最终会在环的起点相遇
//则当Z走向交汇点时，X也走向交汇点
ListNode slowIndex = head;
ListNode fastIndex = head;
if(head==null){
return null;
}
while(fastIndex!=null&&fastIndex.next!=null){
fastIndex = fastIndex.next.next;
slowIndex = slowIndex.next;
if(fastIndex==slowIndex){
ListNode headIndex = head;
while(headIndex!=fastIndex){
headIndex = headIndex.next;
fastIndex = fastIndex.next;
}
return headIndex;
}
}
return null;
}
}