目录
1 148. 排序链表
2 23. 合并 K 个升序链表
3 146. LRU 缓存
3.1 解题思路
3.2 详细过程
3.3 完整代码
菜鸟做题第三周,语言是 C++
解题思路:
class Solution {
public:
ListNode* sortList(ListNode* head) {
ListNode * p = head;
vector vals;
while (p) {
vals.push_back(p->val);
p = p->next;
}
sort(vals.begin(), vals.end());
p = head;
int i = 0;
while (p) {
p->val = vals[i];
p = p->next;
++i;
}
return head;
}
};
解题思路:
class Solution {
public:
ListNode* mergeKLists(vector& lists) {
vector vals;
int n = lists.size();
if (n == 0) return nullptr;
for (int i = 0; i < n; ++i) {
ListNode * p = lists[i];
while (p) {
vals.push_back(p->val);
p = p->next;
}
}
sort(vals.begin(), vals.end());
ListNode * dummy = new ListNode(0);
ListNode * p = dummy;
for (auto &val:vals) {
ListNode * t = new ListNode(val);
p->next = t;
p = t;
}
return dummy->next;
}
};
Q:如何表示某节点最近是否被访问?
A:在我的解法中,将最近被使用的节点链在链表尾部。由此,越靠近头部的节点越少被使用。
Q:什么叫被使用?
A:被使用包含两种:最新被插入到链表中的节点、最新被访问的节点。
Q:为什么一定要构造双向链表?
A:哈希表中存储的是节点的地址,帮助我们快速定位。但是定位只能定位到节点本身,而不能定位到节点的前一个节点,因此使用单向链表将无法完成节点的删除。
① 定义双向链表结构体
struct DListNode {
int key, value;
DListNode * prev, * next;
DListNode() : key(0), value(0), prev(nullptr), next(nullptr) {}
DListNode(int x, int y) : key(x), value(y), prev(nullptr), next(nullptr) {}
};
照抄力扣定义的结构体即可,只不过多了一个 prev 前向指针。
② 定义变量
int cap = 0, size = 0;
unordered_map hashtable;
DListNode * head, * tail;
③ 定义函数
void addToTail(int key, int value) {
DListNode * node = new DListNode(key, value);
hashtable[key] = node;
node->next = tail;
node->prev = tail->prev;
tail->prev->next = node;
tail->prev = node;
++size;
}
void moveToTail(int key) {
DListNode * node = hashtable[key];
node->prev->next = node->next;
node->next->prev = node->prev;
--size;
addToTail(key, hashtable[key]->value);
}
void delHeadNode() {
DListNode * node = head->next;
node->next->prev = head;
head->next = node->next;
delete node;
}
由于在我的解法中 “越靠近头部的节点越少被使用”,所以每次被替换掉的是头节点。
class LRUCache {
public:
struct DListNode {
int key, value;
DListNode * prev, * next;
DListNode() : key(0), value(0), prev(nullptr), next(nullptr) {}
DListNode(int x, int y) : key(x), value(y), prev(nullptr), next(nullptr) {}
};
int cap = 0, size = 0;
unordered_map hashtable;
DListNode * head, * tail;
LRUCache(int capacity) {
cap = capacity;
head = new DListNode();
tail = new DListNode();
head->next = tail;
tail->prev = head;
}
int get(int key) {
if (hashtable.count(key)) {
moveToTail(key);
return hashtable[key]->value;
}
return -1;
}
void put(int key, int value) {
if (hashtable.count(key)) {
hashtable[key]->value = value;
moveToTail(key);
} else if (!hashtable.count(key)) {
if (size < cap) {
addToTail(key, value);
} else if (size >= cap) {
hashtable.erase(head->next->key);
delHeadNode();
addToTail(key, value);
}
}
}
void addToTail(int key, int value) {
DListNode * node = new DListNode(key, value);
hashtable[key] = node;
node->next = tail;
node->prev = tail->prev;
tail->prev->next = node;
tail->prev = node;
++size;
}
void moveToTail(int key) {
DListNode * node = hashtable[key];
node->prev->next = node->next;
node->next->prev = node->prev;
--size;
addToTail(key, hashtable[key]->value);
}
void delHeadNode() {
DListNode * node = head->next;
node->next->prev = head;
head->next = node->next;
delete node;
}
};