目录
1 141. 环形链表
1.1 哈希表
1.2 快慢指针
2 142. 环形链表 II
2.1 哈希表
2.2 快慢指针
3 21. 合并两个有序链表
4 2. 两数相加
菜鸟做题第三周，语言是 C++
1 141. 环形链表
1.1 哈希表
解题思路：遍历链表，在哈希表中查询当前节点地址是否已经存在。若存在，则证明该链表有环，返回 True；若不存在，则将当前节点地址存入哈希表中。如果能够遍历完毕，则返回 False 。
class Solution {
public:
bool hasCycle(ListNode *head) {
ListNode * p = head;
unordered_set<ListNode *> set;
while (p) {
if (set.find(p) != set.end()) return true;
set.insert(p);
p = p->next;
}
return false;
}
};1.2 快慢指针
解题思路：
- 设置一快一慢指针
- 快指针每次移动两格，慢指针每次移动一格
- 如果快指针能够遇上慢指针，那么链表中存在环
思路说明图：
一开始我会想，兔子一定会在同一节点追上乌龟吗？会不会存在，虽然兔子从后面追上了乌龟，但是直接把乌龟超过了。那循环终止的条件怎么写啊？答案是，不存在这种情况。
巧妙之处就在，兔子虽然快，但是也只是每次移动两格。兔子和乌龟每次产生的差距都为 1，而 1 又是所有整数的因子。因此，假设兔子要从后面追上乌龟，且现在的距离为 N，那么经过 N 个时刻后兔子一定追上乌龟，即它们会相遇。
但如果兔子每次移动的不是两格，它和乌龟每次产生的差距为 d，那么就要考虑 N 能不能被 d 整除了。所以兔子每次移动两格不是随便设置的，而是有一定科学依据的。
class Solution {
public:
bool hasCycle(ListNode *head) {
if (head == nullptr) return false;
ListNode * slow = head;
ListNode * fast = head->next;
while (slow != fast) {
if (fast == nullptr || fast->next == nullptr) return false;
slow = slow->next;
fast = fast->next->next;
}
return true;
}
};2 142. 环形链表 II
2.1 哈希表
和上一题的代码几乎一模一样，只是返回的内容不同。
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
unordered_set<ListNode *> set;
ListNode * p = head;
while (p) {
if (set.find(p) != set.end()) return p;
set.insert(p);
p = p->next;
}
return nullptr;
}
};2.2 快慢指针
虽然用哈希表直接秒了，但是用快慢指针也是能做的。。。
请参考官方题解
3 21. 合并两个有序链表
解题思路：
- 设置 p 和 q 指针分管两条链
- 比较 p 和 q 所指向的节点的值
- 按照从小到大的顺序重新连接
注意：不是发现 p->val 小于 q->val 就赶紧重新连接，而是要让 p 继续往后找，找到最后一个小于 q->val 的 p->val，然后才重新连接。否则，不仅违背了从小到大的排序规则，还丢失了节点之间原本的连接。对于 q->val 小于 p->val 的情况同理。
思路说明图：这四幅图的顺序是从左到右，从上到下。
对于 p->val == q->val 的情况，哪边连哪边都无所谓。
class Solution {
public:
ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
if (list1 == nullptr && list2 == nullptr) return nullptr;
if (list1 == nullptr) return list2;
if (list2 == nullptr) return list1;
ListNode * p = list1, * q = list2;
while (p && q) {
if (p->val <= q->val) {
while (p->next && p->next->val <= q->val) p = p->next;
ListNode * temp = p->next;
p->next = q;
p = temp;
} else if (p->val >= q->val) {
while (q->next && p->val >= q->next->val) q = q->next;
ListNode * temp = q->next;
q->next = p;
q = temp;
}
}
return list1->val <= list2->val ? list1 : list2;
}
};
说明：这两行代码就是我说的 “要让 p 或 q 继续往后找”
while (p->next && p->next->val <= q->val) p = p->next;
while (q->next && p->val >= q->next->val) q = q->next;4 2. 两数相加
这道题比我想象的简单，我以为要算最后的总和，结果只需要算每一位的结果
解题思路：
- 设置进位 carry
- 每一位结果 = (p->val + q->val + carry) % 10
- 如果 p->val + q->val + carry > 10，则新的 carry = 1
最重要的其实是 l1 和 l2 可能不一样长，因此需要考虑一条链表已经遍历完毕，而另一条链表还没有遍历完毕的情况。因此进行了如下处理：
int n1 = p ? p->val : 0;
int n2 = q ? q->val : 0;
// ...
if (p) p = p->next;
if (q) q = q->next;如果 p 或者 q 遍历完了，那么用 0 参加加法运算即可。
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode * head = new ListNode(0), * tail = head;
int carry = 0;
ListNode * p = l1, * q = l2;
while (p || q) {
int n1 = p ? p->val : 0;
int n2 = q ? q->val : 0;
int sum = n1 + n2 + carry;
tail->next = new ListNode(sum % 10);
tail = tail->next;
carry = sum / 10;
if (p) p = p->next;
if (q) q = q->next;
}
if (carry) {
tail->next = new ListNode(carry);
}
return head->next;
}
};
