24. 两两交换链表中的节点
视频讲解:帮你把链表细节学清楚! | LeetCode:24. 两两交换链表中的节点_哔哩哔哩_bilibili
思路:
题意要求两两交换链表中的节点 ,首先可以想到:
1.两个节点的交换
2.整个链表的遍历
对于两个节点的交换可以将操作指针cur放在两个交换节点的前一个节点,然后进行交换,随后将cur指针进行移动,可以实现对整个链表的遍历。
如图所示,给了一个链表两个节点交换的范例:
依然是运用虚拟头结点dummyhead,操作指针cur需要指向两个反转节点的前一个节点。
循环退出条件:
cur->next = NULL(偶数个节点)
cur->next->next = NULL(奇数个节点)
对节点1和3需要记录一个临时节点,防止过程中找不到节点。
节点1:temp = cur->next
节点3:temp1 = cur->next->next->next
步骤:
(1)cur->next = cur->next->next
(2)cur->next->next = temp
(3)temp->next = temp1
代码:
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
dummyHead->next = head; // 将虚拟头结点指向head,这样方面后面做删除操作
ListNode* cur = dummyHead;
while(cur->next != nullptr && cur->next->next != nullptr) {
ListNode* tmp = cur->next; // 记录临时节点
ListNode* tmp1 = cur->next->next->next; // 记录临时节点
cur->next = cur->next->next; // 步骤一
cur->next->next = tmp; // 步骤二
cur->next->next->next = tmp1; // 步骤三
cur = cur->next->next; // cur移动两位,准备下一轮交换
}
return dummyHead->next;
}
};
- 时间复杂度:O(n)
- 空间复杂度:O(1)
19.删除链表的倒数第N个节点
视频讲解:链表遍历学清楚! | LeetCode:19.删除链表倒数第N个节点_哔哩哔哩_bilibili
思路:
如何找到链表的倒数第N个节点呢?
可以使用双指针的方法,定义一个fast指针和一个slow指针,fast先移动N步,随后fast和slow同时移动,当fast指向NULL的时候,slow指向的就是倒数第N个节点。
但是如果想要删除一个节点,指针就必须指向要删除节点的前一个节点,所以可以使fast先移动N+1步,然后fast和slow在同时移动,这样slow就指向的是要删除节点的前一个节点。
下图是删除链表的倒数第2个节点的范例:
代码:
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* slow = dummyHead;
ListNode* fast = dummyHead;
while(n-- && fast != NULL) {
fast = fast->next;
}
fast = fast->next; // fast再提前走一步,因为需要让slow指向删除节点的上一个节点
while (fast != NULL) {
fast = fast->next;
slow = slow->next;
}
slow->next = slow->next->next;
// ListNode *tmp = slow->next; C++释放内存的逻辑
// slow->next = tmp->next;
// delete nth;
return dummyHead->next;
}
};
- 时间复杂度: O(n)
- 空间复杂度: O(1)
面试题 02.07. 链表相交
思路:
简单来说就是求两个链表交点节点的指针,注意交点不是数值相等而是指针相等。
假设节点元素数值相等,则节点指针相等。
求出两个链表长度的差值,然后让curA移动到和curB末尾对齐的位置。
然后比较curA和curB是否相同,如果不相同,就同时向后移动直到curA == curB。
代码:
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode* curA = headA;
ListNode* curB = headB;
int lenA = 0, lenB = 0;
while (curA != NULL) { // 求链表A的长度
lenA++;
curA = curA->next;
}
while (curB != NULL) { // 求链表B的长度
lenB++;
curB = curB->next;
}
curA = headA;
curB = headB;
// 让curA为最长链表的头,lenA为其长度
if (lenB > lenA) {
swap (lenA, lenB);
swap (curA, curB);
}
// 求长度差
int gap = lenA - lenB;
// 让curA和curB在同一起点上(末尾位置对齐)
while (gap--) {
curA = curA->next;
}
// 遍历curA 和 curB,遇到相同则直接返回
while (curA != NULL) {
if (curA == curB) {
return curA;
}
curA = curA->next;
curB = curB->next;
}
return NULL;
}
};
- 时间复杂度:O(n + m)
- 空间复杂度:O(1)
142.环形链表II
视频讲解:把环形链表讲清楚! 如何判断环形链表?如何找到环形链表的入口? LeetCode:142.环形链表II_哔哩哔哩_bilibili
思路:
判断环:
定义一个快指针和一个慢指针,快指针比慢指针走的要快,如果有环的话他俩肯定会相遇。
每当慢指针前进一步,快指针前进两步,当快指针遇到慢指针则说明有环,反之则无环。
所以我们可以设置速度为:
快指针:一次走两步
慢指针:一次走一步
找出环的入口:
当n = 1时,意味着fast指针在环形里转了一圈之后,就遇到了slow指针。
当n = 1时,x = z。这就意味着从头节点出发一个指针index1,从相遇节点也出发一个指针index2,这两个指针每次只走一个节点,那么相遇的地方就是入口的节点。
代码:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* fast = head;
ListNode* slow = head;
while(fast != NULL && fast->next != NULL) {
slow = slow->next;
fast = fast->next->next;
// 快慢指针相遇,此时从head 和 相遇点,同时查找直至相遇
if (slow == fast) {
ListNode* index1 = fast;
ListNode* index2 = head;
while (index1 != index2) {
index1 = index1->next;
index2 = index2->next;
}
return index2; // 返回环的入口
}
}
return NULL;
}
};
- 时间复杂度: O(n),快慢指针相遇前,指针走的次数小于链表长度,快慢指针相遇后,两个index指针走的次数也小于链表长度,总体为走的次数小于 2n
- 空间复杂度: O(1)