Datawhale|LeetCodeTencent Task12(lc146,148, 155)

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(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();
    }
};