目录
今日学习的文章
写代码的时候最好对照图像的逻辑来写,可以画个图,模拟,不会太乱
两两交换链表中的节点
看到题目的第一想法
这道题的目标时要将链表中的节点,每两个两个进行交换,我看到题目第一时间选择画图,以及回忆了之前链表反转的代码,但是在控制指针时还是容易乱
看到代码随想录之后的想法
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<n+1;i++){
if(fastIndex==null){
return newHead.next;
}
fastIndex = fastIndex.next;
}
//一起往后走
while(fastIndex!=null){
fastIndex = fastIndex.next;
slowIndex = slowIndex.next;
}
//删除slow后面的元素
slowIndex.next = slowIndex.next.next;
return newHead.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
//若n步也可以 while循环中的条件为fast.next!=null
ListNode newHead= new ListNode();
newHead.next = head;
ListNode fastIndex = newHead;
ListNode slowIndex = newHead;
//fast先走
for(int i=0;i<n;i++){
if(fastIndex.next==null){
return newHead.next;
}
fastIndex = fastIndex.next;
}
//一起往后走
while(fastIndex.next!=null){
fastIndex = fastIndex.next;
slowIndex = slowIndex.next;
}
//删除slow后面的元素
slowIndex.next = slowIndex.next.next;
return newHead.next;
}
}
看到题目的第一想法
计算出两个链表的长度再相减,然后再用双指针走
看到代码随想录之后的想法
计算出两个链表的长度再相减得到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;i<offset;i++){
if(countA<countB){
listNodeB = listNodeB.next;
}
if(countA>countB){
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;
}
}