目录
心得体会：
链表基础操作比较简单，主要还是掌握题目的解题思路。
24. 两两交换链表中的节点
题目链接：24. 两两交换链表中的节点
一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。（只能进行节点交换）
虚拟头节点-三步法：
-
思考过程：
- 初始时，cur指向虚拟头结点，然后进行如下三步：
- 操作之后，链表如下：
-
解题细节：
- 指针使用前一定要先判断是否为 nullptr，例如：使用 cur->next->next->next 时，一定要判断 cur->next->next != nullptr 。
-
力扣代码:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* cur = dummyHead;
while (cur->next != nullptr && cur->next->next != nullptr) { //此处判断 cur->next->next != nullptr,不需要对 cur->next->next->next 判断，它可以为空，类比[1,2,3,4]，最后一位4指向为空
ListNode* temp1 = cur->next; // 1的地址
ListNode* temp2 = cur->next->next; // 2的地址
ListNode* temp3 = cur->next->next->next; // 3的地址
cur->next = temp2;
cur->next->next = temp1;
cur->next->next->next = temp3;
cur = cur->next->next;
}
head = dummyHead->next;
delete dummyHead;
return head;
}
};19.删除链表的倒数第N个节点
题目链接：19. 删除链表的倒数第 N 个结点
给你一个链表，删除链表的倒数第
n个结点，并且返回链表的头结点。
题目建议：掌握双指针法。
双指针法：
-
思考过程：
- 如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾；
- 双指针的操作，要注意，删除第N个节点，那么我们当前遍历的指针一定要指向 第N个节点的前一个节点。
-
解题细节：
- 记得在return之前，delete 在堆区申请的虚拟头节点和待删除的节点；
- fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作）：
- fast和slow同时移动，直到fast指向末尾，删除slow指向的下一个节点：
-
力扣代码:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* fast = dummyHead;
ListNode* slow = dummyHead;
// fast 移动 n+1 步
while (n-- && fast != nullptr) {
fast = fast->next;
}
fast = fast->next;
// fast 和 slow 同时移动
while (fast != nullptr) {
fast = fast->next;
slow = slow->next;
}
// 删除链表节点,指向下一个节点
ListNode* temp = slow->next;
slow->next = slow->next->next;
delete temp;
temp = nullptr;
head = dummyHead->next;
delete dummyHead;
return head;
}
};面试题 02.07. 链表相交
题目链接：面试题 02.07. 链表相交
给你两个单链表的头节点
headA和headB，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回null。
题目建议：
末尾对齐法：
-
思考过程：
- 我们求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置：
此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。否则循环退出返回空指针。
-
解题细节：
- 交点不是数值相等，而是指针相等；
-
力扣代码:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
// 求出两个链表的长度，计算差值
int _sizeA = 0;
ListNode* curA = headA;
while (curA != nullptr) {
curA = curA->next;
_sizeA++;
}
int _sizeB = 0;
ListNode* curB = headB;
while (curB != nullptr) {
curB = curB->next;
_sizeB++;
}
// 将curA移动到和curB 末尾对齐的位置
curA = headA;
curB = headB;
int n = abs(_sizeA -_sizeB);
if (_sizeA > _sizeB) { // A链表 更长
while (n-- && curA != nullptr) {
curA = curA->next;
}
} else { // B链表 更长
while (n-- && curB != nullptr) {
curB = curB->next;
}
}
// 判断curA == curB，则找到交点
while (curA != curB ) {
curA = curA->next;
curB = curB->next;
}
if (curA == nullptr || curB == nullptr) {
return nullptr;
} else {
ListNode* intersection = curA; // 交点
return intersection;
}
}
};142.环形链表II
题目链接：142. 环形链表 II
给定一个链表的头节点
head，返回链表开始入环的第一个节点。 如果链表无环，则返回null。
主要考察两知识点：
- 判断链表是否环
- 如果有环，如何找到这个环的入口
快慢指针法：
-
思考过程：
- 使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。
- 相遇时： slow指针走过的节点数为:
x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。
- fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2，xyz 之间的关系为：
(x + y) * 2 = x + y + n (y + z) x + y = n (y + z) x = n (y + z) - y x = (n - 1) (y + z) + z // n 大于等于1
- 从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。
-
解题细节：
- 判断有没有环；如果有找到 slow 和 fast 在环内相遇的节点；
- 在头节点和相遇节点出发的两个指针，同时往前移，相遇点就是入环点；
关于回答“为什么第一次在环中相遇，slow的 步数 是 x+y 而不是 x + 若干环的长度 + y 呢？”
- 首先对于 slow 而言 fast 是一步一步靠近slow；
- 当 slow 入环时，fast 一定在环内，两者之间的步长肯定小于环长；
- 在 slow 第二次环之前，fast 肯定能找到 slow ，因此slow入环只会小于一圈；
-
力扣代码:
/**
* 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) {
if (head == nullptr) return nullptr; //关键：使用fast指针前，先判断其是否为nullptr
// 判断有没有环;
// 如果有找到 slow 和 fast 在环内相遇的节点；
ListNode* slow = head;
ListNode* fast = head;
while (fast != nullptr && fast->next != nullptr) {
slow = slow->next;
fast = fast->next->next;
if (slow == fast) break;
}
if (fast == nullptr || fast->next == nullptr) return nullptr;
// 在头节点和相遇节点出发的两个指针，同时往前移，相遇点就是入环点
// x = (n-1)*(y+z) + z;
ListNode* index1 = head;
ListNode* index2 = fast;
while (index1 != nullptr && index2 != nullptr && index1 != index2) {
index1 = index1->next;
index2 = index2->next;
}
ListNode* up2ring = index1; // 入环节点
return up2ring;
}
};
355
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
