打卡Day5
- 1.24.两两交换链表中的节点
- 2.19.删除链表的倒数第N个节点
- [3.面试题 02.07. 链表相交](#3.面试题 02.07. 链表相交)
- 4.142.环形链表II
1.24.两两交换链表中的节点
题目链接:两两交换链表中的节点
文档讲解: 代码随想录
java
class Solution {
public ListNode swapPairs(ListNode head) {
//虚拟节点
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode cur = dummy;
ListNode temp;//保存第三个节点
ListNode firstNode;//保存第一个节点
ListNode seconfNode;//保存第二个节点
while(cur.next != null && cur.next.next != null){
temp = cur.next.next.next;
firstNode = cur.next;
seconfNode = cur.next.next;
cur.next = seconfNode;
seconfNode.next = firstNode;
firstNode.next = temp;
cur = firstNode;
}
return dummy.next;
}
}
java
//改变互换的步骤顺序
class Solution {
public ListNode swapPairs(ListNode head) {
ListNode dummy = new ListNode(0,head);
ListNode cur = dummy;
while(cur.next != null && cur.next.next != null){
ListNode node1 = cur.next;
ListNode node2 = cur.next.next;
cur.next = node2;
node1.next = node2.next;
node2.next = node1;
cur = node1;
}
return dummy.next;
}
}
递归法:
首先写边缘条件
java
if(head == null || head.next == null){
return head;
}
将1节点和2节点相互交换,先将next.next指向head,head.next指向新节点,然后返回2节点。而递归就在于将后移,以第一次为例进行说明,输入head(节点1)返回节点2,那么下一次,则需要输入3节点,输出4节点,即为next.next。
java
class Solution {
public ListNode swapPairs(ListNode head) {
if(head == null || head.next == null){
return head;
}
//获取当前节点的下一个节点
ListNode next = head.next;
//递归
ListNode newNode = swapPairs(next.next);
next.next = head;
head.next = newNode;
return next;
}
}
2.19.删除链表的倒数第N个节点
题目链接:删除链表的倒数第N个节点
文档讲解: 代码随想录
java
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
//新建虚拟节点
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode fastNode = dummy;
ListNode slowNode = dummy;
for(int i = 0; i <= n; i++){
fastNode = fastNode.next;
}
while(fastNode != null){
fastNode = fastNode.next;
slowNode = slowNode.next;
}
if(slowNode.next != null){
//避免空指针异常
slowNode.next = slowNode.next.next;
}
return dummy.next;
}
}
3.面试题 02.07. 链表相交
题目链接:面试题 02.07. 链表相交
文档讲解: 代码随想录
java
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
int countA = 0;
int countB = 0;
ListNode curA = headA;
ListNode curB = headB;
while(curA != null){
countA++;
curA = curA.next;
}
while(curB != null){
countB++;
curB = curB.next;
}
curA = headA;
curB = headB;
//让A变为长链
if(countB > countA){
int tem = countA;
countA = countB;
countB = tem;
ListNode temp = curA;
curA = curB;
curB = temp;
}
int cha = countA - countB;
while(cha > 0){
curA = curA.next;
cha--;
}
while(curA != null){
if(curA == curB){
return curA;
}
curA = curA.next;
curB = curB.next;
}
return null;
}
}
两个注意点:
(1)查找的交点并不是找值相同的节点,而是找指针相同的节点。通过将两个链表后靠齐,然后移动长链表的开始指针到差值处,就可以比较curA和curB是否相同。
(2)关于A和B谁长的问题,两种情况,想让A链永远长,那就可以在B长的时候进行AB对换。
4.142.环形链表II
题目链接:环形链表II
文档讲解: 代码随想录
(1)如何想到用快慢指针:如果链表无环,则快慢指针永远无法相遇。一旦快慢指针相遇,则说明一定存在有环。
(2)快指针无法越过慢指针继续打转(即快指针一定是在慢指针一圈没有走完的情况遇到了慢指针):慢指针进入环,快指针步速为2,相对于慢指针的步速1,是一次一步的靠近慢指针,肯定无法错过慢指针。假设慢指针走完一圈,以快指针的速度,已经走完两圈了,一定会在圈内超过慢指针。
慢指针:x+y
快指针:x+y+n(y+z)
n:表示快指针在环内走的圈数
因为相遇,所以可以得到等式:2(x+y)= x+y+n(y+z)
两边约掉x+y,可得:x+y = n(y+z)=(n-1)(y+z)+ y+z
所以x = (n-1)(y+z)+z
由于y+z是定值,我们可以以n=1的特例看出,当快慢指针相遇后,x = z,从相遇的时间开始算起,从head以及相遇点同时出发的指针会在入口处相遇,就可以得到入环点。
java
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode fast = head;
ListNode slow = head;
while(fast != null && fast.next != null){
fast = fast.next.next;
slow = slow.next;
if(fast == slow){
//有环
ListNode index1 = slow;
ListNode index2 = head;
// if(index1 == index2){
// return index1;
// }
// index1 = index1.next;
// index2 = index2.next;
while(index1 != index2){
index1 = index1.next;
index2 = index2.next;
}
return index1;
}
}
return null;
}
}
关于
java
// if(index1 == index2){
// return index1;
// }
// index1 = index1.next;
// index2 = index2.next;
我一开始用的if,在力扣里面显示超过时间限制,原因是if在快慢指针相遇的时候只判断了一次index1 == index2,一般情况下是不等的,所以会死循环。
感觉这道题,难在思路。有时候,自己写思路想不到;看了思路,代码不会写。学代码真痛苦!