题目链接:24. 两两交换链表中的节点 - 力扣(LeetCode)
设置虚拟头结点解决。初始时,cur指向虚拟头结点,然后进行如下三步:
操作之后,链表如下:
class Solution24 {
public ListNode swapPairs(ListNode head) {
if (head == null) return head;
ListNode dummy = new ListNode(-1, head);
ListNode cur = dummy;
while (cur.next != null && cur.next.next != null){
ListNode temp = cur.next;
ListNode temp2 = cur.next.next.next;
cur.next = cur.next.next;
cur.next.next = temp;
cur.next.next.next = temp2;
cur = cur.next.next;
}
return dummy.next;
}
}
- 时间复杂度:O(n)
- 空间复杂度:O(1)
题目链接:19. 删除链表的倒数第 N 个结点 - 力扣(LeetCode)
双指针的经典应用,如果要删除倒数第n个节点,让fast移动n步,然后让fast和slow同时移动,直到fast指向链表末尾。删掉slow所指向的节点就可以了。
-
定义fast指针和slow指针,初始值为虚拟头结点,如图:
fast首先走n + 1步 ,为什么是n+1呢,因为只有这样同时移动的时候slow才能指向删除节点的上一个节点(方便做删除操作),如图:
fast和slow同时移动,直到fast指向末尾,如题:
删除slow指向的下一个节点,如图:
class Solution19 {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode dummy = new ListNode(-1, head);
ListNode first = dummy;
ListNode second = dummy;
// 先使得first与second之间的间隔为n (n个节点)
for (int i = 0; i <= n; i++) {
first = first.next;
}
// 同时移动,直到first到达null
while(first != null){
first = first.next;
second = second.next;
}
// 删除second.next节点
second.next = second.next.next;
return dummy.next;
}
}
题目链接:面试题 02.07. 链表相交 - 力扣(LeetCode)
简单来说,就是求两个链表交点节点的指针。要注意,交点不是数值相等,而是指针相等。
看如下两个链表,目前curA指向链表A的头结点,curB指向链表B的头结点:
我们求出两个链表的长度,并求出两个链表长度的差值,然后让curA移动到,和curB 末尾对齐的位置,如图:
此时我们就可以比较curA和curB是否相同,如果不相同,同时向后移动curA和curB,如果遇到curA == curB,则找到交点。 否则循环退出返回空指针。
class Solution160 {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode curA = headA;
ListNode curB = headB;
int lenA = 0, lenB = 0;
while (curA != null){
curA = curA.next;
lenA ++;
}
while (curB != null){
curB = curB.next;
lenB++;
}
curA = headA;
curB = headB;
if (lenB > lenA){
// swap(lenA ,lenB);
int temp1 = lenA;
lenA = lenB;
lenB = temp1;
// swap(curA, curB);
ListNode temp2 = curA;
curA = curB;
curB = temp2;
}
int gap = lenA - lenB; // 长度差
// 让curA curB在同一起点上
for (int i = 0; i < gap; i++) {
curA = curA.next;
}
// 遍历curA 和 curB 遇到相同就返回
while(curA != null){
if (curA == curB) return curA;
curA = curA.next;
curB = curB.next;
}
return null;
}
}
题目链接:142. 环形链表 II - 力扣(LeetCode)
思考两个问题:
- 如何判断链表是否环?
- 如果有环,如何找到这个环的入口?
判断链表是否有环
可以使用快慢指针法,分别定义 fast 和 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同时移动,每次移动一个节点, 那么他们相遇的地方就是 环形入口的节点。
class Solution142 {
public ListNode detectCycle(ListNode head) {
// 如何判断链表是否有环?
// 可以使用快慢指针法,分别定义 fast 和 slow 指针,从头结点出发,fast指针每次移动两个节点,slow指针每次移动一个节点,如果 fast 和 slow指针在途中相遇 ,说明这个链表有环。
ListNode fast = head;
ListNode slow = head;
while(fast != null && fast.next != null){
fast = fast.next.next;
slow = slow.next;
// 如果有环,如何找到这个环的入口
// 如果快慢指针相遇 此时从head和相遇点,同时查找直至相遇 (思考为什么?)
if (slow == fast){
ListNode index1 = fast;
ListNode index2 = head;
while(index2 != index1){
index1 = index1.next;
index2 = index2.next;
}
return index2; // 环入口
}
}
return null;
}
}