Content
146. LRU Cache
Description
Analysis & Solution
LRU即最近最少使用原则。当存入数据时,若缓存超过容量,则将最近最小使用的数据删除。使用双向链表加哈希表构成的哈希链表。
每次put(key, value),若key存在,更新其value值。若key不存在,且不超过容量,建立新节点插入链表头部;若不key存在且超过容量,删除头结点后再插入新节点。
每次get(key)时,用哈希表查询返回其value,同时将该节点移动到链表末尾。
Code
class LRUCache {
public:
LRUCache(int capacity) : cap(capacity) {
}
int get(int key) {
if (map.find(key) == map.end()) return -1;
auto key_value = *map[key];
cache.erase(map[key]);
cache.push_front(key_value);
map[key] = cache.begin();
return key_value.second;
}
void put(int key, int value) {
if (map.find(key) == map.end()) {
if (cache.size() == cap) {
map.erase(cache.back().first);
cache.pop_back();
}
}
else {
cache.erase(map[key]);
}
cache.push_front({key, value});
map[key] = cache.begin();
}
private:
int cap;
list<pair<int, int>> cache;
unordered_map<int, list<pair<int, int>>::iterator> map;
};
148. Sort List
Description
Analysis & Solution
用 O ( n l o g n ) O(nlogn) O(nlogn)的时间复杂度排序链表,可以类比数组的排序方法。本题目采用归并排序,先用快慢指针遍历找到链表中点,左右两部分使用递归进行排序,最后用merge将排序结果归并。
Code
ListNode* mergeSort(ListNode *head)
{
if(head == nullptr || head->next == nullptr) return head;
if(head->next->next == nullptr)
{
if(head->val > head->next->val)
{
int temp = head->val;
head->val = head->next->val;
head->next->val = temp;
}
return head;
}
ListNode *fast = head, *slow = head;
while(fast != nullptr && fast->next != nullptr)
{
fast = fast->next->next;
slow = slow->next;
}
ListNode *mid = slow->next;
slow->next = nullptr;
ListNode *leftHalf = mergeSort(head);
ListNode *rightHalf = mergeSort(mid);
return merge(leftHalf, rightHalf);
}
ListNode* merge(ListNode *l, ListNode *r)
{
ListNode *dummyNode = new ListNode(0);
ListNode *cur = dummyNode;
while(l != nullptr && r != nullptr)
{
if(l->val < r->val)
{
cur->next = l;
cur = cur->next;
l = l->next;
}
else
{
cur->next = r;
cur = cur->next;
r = r->next;
}
}
cur->next = (l == nullptr ? r : l);
return dummyNode->next;
}
155. Min Stack
Description
Analysis & Solution
与普通栈的区别是多了一个返回栈内最小值的功能。可以使新建一个min_stack作为辅助栈。min_stack中存储栈中每个元素作为栈顶时栈的最小值。
Code
class MinStack {
stack<int> x_stack;
stack<int> min_stack;
public:
MinStack() {
min_stack.push(INT_MAX);
}
void push(int x) {
x_stack.push(x);
min_stack.push(min(min_stack.top(), x));
}
void pop() {
x_stack.pop();
min_stack.pop();
}
int top() {
return x_stack.top();
}
int getMin() {
return min_stack.top();
}
};