24. 两两交换链表中的节点
1.注意理清操作顺序,记录临时节点
//时间复杂度:O(n)
//空间复杂度:O(1)
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;
}
};
19.删除链表的倒数第N个节点
1、使用双指针,先让fast移动n步,然后让fast和slow同时移动,直到fast指向链表末尾。删掉slow所指向的节点。
//时间复杂度:O(n)
//空间复杂度:O(1)
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummyHead = new ListNode();
dummyHead -> next = head;
ListNode* fastNode = dummyHead;
ListNode* slowNode = dummyHead;
// for(int i = 0; i<n; i++){
// fastNode = fastNode ->next;
// if(fastNode == nullptr)
// return head;
// }
while(n-- && fastNode != nullptr){
fastNode = fastNode ->next;
}
while(fastNode->next != nullptr){
slowNode = slowNode -> next;
fastNode = fastNode -> next;
}
ListNode* temp = slowNode -> next;
slowNode -> next = slowNode ->next ->next;
delete temp;
return dummyHead->next;
}
};
面试题 02.07. 链表相交
1、法1:两个节点同时走m+n的长度,找到相交的点。若没有相交的点,nodeA和nodeB最后都会变为空指针,跳出while循环,并返回空指针
//时间复杂度:O(n+m)
//空间复杂度:O(1)
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode* nodeA = headA;
ListNode* nodeB = headB;
if(headA == nullptr || headB == nullptr)
return nullptr;
while(nodeA != nodeB){
nodeA = nodeA == nullptr ? headB : nodeA -> next;
nodeB = nodeB == nullptr ? headA : nodeB -> next;
}
return nodeA;
}
};
2、法2:使用map存储节点,判断是否有相等指针。空间复杂度较大
//时间复杂度:O(n+m)
//空间复杂度:O(m)
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
unordered_set<ListNode *> visited;
ListNode *temp = headA;
while (temp != nullptr) {
visited.insert(temp);
temp = temp->next;
}
temp = headB;
while (temp != nullptr) {
if (visited.count(temp)) {
return temp;
}
temp = temp->next;
}
return nullptr;
}
};
3、法3:求出A和B的长度,将指针差值补齐,再寻找相等节点
//时间复杂度:O(n+m)
//空间复杂度:O(1)
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;
}
};
142.环形链表II
1、判断链表是否环:fast 和 slow指针在途中相遇,且一定是在环中相遇
2、找到环的入口:先找到fast和slow相遇的点,再从head和相遇点同时查找直到相遇
3、因为数学公式推导得 x = (n - 1) (y + z) + z,x是head到环入口的距离,(n - 1) (y + z) + z是(多绕整圈长度距离)+(相遇点到环入口的距离)【n=1时,x=z】,所以head和相遇点同时查找能找到环入口的位置
3、数学逻辑推导有些绕,需要多加理解
//时间复杂度: O(n),快慢指针相遇前,指针走的次数小于链表长度,
//快慢指针相遇后,两个index指针走的次数也小于链表长度,总体为走的次数小于 2n
//空间复杂度: O(1)
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;
}
};