两两交换链表中的节点
题目链接
视频链接
帮你把链表细节学清楚! | LeetCode:24. 两两交换链表中的节点
思路:
利用虚拟头节点完成对节点交换的操作,需要先画图,确认间交换的步骤
注意点:、
1.确定temp指针为需要操作的指针的前一个位置
2.若有奇数个节点,最后一个节点不需要操作所以退出遍历的条件为(temp.next.next!=null)
若有偶数个节点就可以一一交换,退出遍历的条件为(temp.next!=null)所以遍历的判断条件为
while(temp.next!=null&&temp.next.next!=null)
3.因为后续操作会改变temp.next指向(如图节点1,同理节点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 {
public ListNode swapPairs(ListNode head) {
ListNode dummyhead=new ListNode(0);
dummyhead.next=head;//虚拟头节点
ListNode temp=dummyhead;
while(temp.next!=null&&temp.next.next!=null){
//提前保存好temp.next和temp.next.next.next
ListNode n1=temp.next;
ListNode n3=temp.next.next.next;
temp.next=temp.next.next;//temp->2
temp.next.next=n1;//2->1
n1.next=n3;//1->3
temp=temp.next.next;//temp指针向后移动两个位置
}
return dummyhead.next;//返回头节点
}
}
删除链表的倒数第N个节点
题目链接
视频链接
链表遍历学清楚! | LeetCode:19.删除链表倒数第N个节点
思路:
通过双指针,找到待删除的位置,然后进行删除,定义指针fast,slow指向虚拟头节点,向让fast指针移动n次,后继续让fast指针移动一次(这样最后是得到slow指针指向的是需要被删除的节点的前一个节点,便于删除操作),之后fast和slow指针同时移动知道fast指针直至链表的末端
代码:
/**
* 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) {
ListNode dummyHead=new ListNode(0);
dummyHead.next=head;
//定义fast,slow指针
ListNode fast=dummyHead;
ListNode slow=dummyHead;
while(n-->0){//先让fast指针移动n次
fast=fast.next;
}
while(fast.next!=null){//slow和fast指针同时移动
fast=fast.next;
slow=slow.next;
}
slow.next=slow.next.next;
return dummyHead.next;
}
}
面试题 02.07. 链表相交
题目链接
思路:
我们求出两个链表的长度,并求出两个链表长度的差值,然后让curA(指向更长的链表)移动到,和curB 末尾对齐的位置,此时我们就可以比较curA和curB是否相同,如果不相同,同时向后移动curA和curB,如果遇到curA == curB,则找到交点。
否则循环退出返回空指针。
代码:
/**
* 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 dummyHead_A=new ListNode(0);
dummyHead_A.next=headA;
ListNode dummyHead_B=new ListNode(0);
dummyHead_B.next=headB;
ListNode tempA=dummyHead_A;
ListNode tempB=dummyHead_B;
int LenA=0;
int LenB=0;
//计算链表A,B 的长度
while(tempA.next!=null){
LenA++;
tempA=tempA.next;
}
while(tempB.next!=null){
LenB++;
tempB=tempB.next;
}
//指针重新指向链表头部
tempA=headA;
tempB=headB;
// 让curA为最长链表的头,lenA为其长度
if (LenB > LenA) {
int tmpLen = LenA;
LenA = LenB;
LenB = tmpLen;
ListNode tmpNode = tempA;
tempA = tempB;
tempB = tmpNode;
}
int gapLen=LenA-LenB;
while(gapLen-->0){
tempA=tempA.next;
}
while(tempA!=null){
ListNode a=tempA;
ListNode b=tempB;
if(a==b){//比较a,b是否相等
return a;
}
tempA=tempA.next;
tempB=tempB.next;
}
return null;
}
}
环形链表II
题目链接
视频链接
把环形链表讲清楚! 如何判断环形链表?如何找到环形链表的入口? LeetCode:142.环形链表II
思路:
1.判断是否有环:
通过设置一个快指针,和一个慢指针(快指针每次走来两个节点,慢指针每次走一个节点,如果链表中有环,快慢指针就会相遇),这样就可以判断是否有环了。
为什么有环一定会相遇? -->快指针会先进入环中,慢指针进入环中后,因为快指针相对慢指针开速度快一个节点,所以随着时间就一定会追上
2.找到循环入口
那么来看一下,为什么fast指针和slow指针一定会相遇呢?
可以画一个环,然后让 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): x + y = n (y + z)
因为要找环形的入口,那么要求的是x,因为x表示 头结点到 环形入口节点的的距离。
所以要求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,相遇点依然是环形的入口节点。
代码:
/**
* 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) {
ListNode fast;
ListNode slow;
fast=head;
slow=head;
while(fast!=null&&fast.next!=null){
fast=fast.next.next;
slow=slow.next;
if(fast==slow){//如果有环
ListNode n1=head;
ListNode n2=fast;
while(n1!=n2){
n1=n1.next;
n2=n2.next;
}
return n1;
}
}
return null;
}
}