本文已参与「新人创作礼」活动，一起开启掘金创作之路。

这种题目也称为大数相加，思路比较简单，但没那么好写出来定义两个指针，分别指向第一个字符串和第二个字符串的某位，也就是最低位定义进位并将其初始化为零两个数字相加的终止条件就是第一个数的当前位和第二个数的当前位都为0并且进位也为零，按照这样的思路我们可以这样来写

class Solution {
public:
    string addStrings(string num1, string num2) {
        string res = "";
        int i = num1.length() - 1, j = num2.length() - 1;
        int carry = 0;

        while(i >= 0 || j >= 0 || carry != 0) {
            if(i >= 0) {
                carry += num1[i--] - '0';
            }
            if(j >= 0) {
                carry += num2[j--] - '0';
            }
            res += to_string(carry % 10);
            //两种方式选一种就好，我更喜欢调用库函数
            res.push_back('0' + carry % 10);
            
            carry /= 10;//	确定进位
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

首先，我们得了解LRU缓存是什么意思，按照网上的说法是这样来理解的。比如说，我有一百万个数据，我的客户端需要从一百万个数据中找到我需要的数据，这样消耗的时间会很多，而我们在中间弄一个缓存结构，里面的容量是一万个数据单位，我们每查阅一次，就会把数据放进缓存结构里，如果有重复的，就将之前存进来的数据放在前面，直到容量满了，再存入一个新的数据时，就得把之前数据的最近最少使用的数据给剔除出缓存结构，将新的数据放进缓存结构里，这样我们客户端访问数据所需要的时间就会大大缩小，这也就是LRU缓存结构的意思，即最近最少使用。

那么我们就可以开始想如何才能达到我们的目的。按照题目的要求，我们只能使用时间复杂度为O(1)的结构，那我们可以使用哈希表和双向链表来解决这道题目 1.先将双向链表和哈希表定义出来，定义完之后，我们再定义容量的大小和==哨兵节点（防止首节点为空时(first == null),出现无法指向下个节点情况。哨兵节点指向的下个单元为首节点。）== 2.初始化哨兵节点并且赋值，然后将两个哨兵节点双向连接 3.写一个移除函数和一个插入函数 4.补充查看和更新函数图中所示是对链表中的元素进行插入的流程图插入函数的草图理解

class LRUCache {
public:
    struct Node {//双向链表
        int key, value;
        Node* prev, *next;
        Node(int k, int v) : key(k), value(v), prev(nullptr), next(nullptr){}
    };
    Node* head, *tail;
    int _capacity;
    unordered_map<int, Node*> map;

    LRUCache(int capacity) {
        _capacity = capacity;
        head = new Node(-1, -1);
        tail = new Node(-1, -1);
        head->next = tail;
        tail->prev = head;
    }
    
    int get(int key) {//查看函数
        if(map.count(key)) {
            Node* node = map[key];
            remove(node);
            insert(node->key, node->value);

            return node->value;
        }else {
            return -1;
        }
    }
    
    void put(int key, int value) {//更新函数
        if(map.count(key)) {
            Node* node = map[key];
            remove(node);
            insert(key, value);
        }else {
            if(map.size() == _capacity) {
                Node* node = tail->prev;
                remove(node);
                insert(key, value);
            }else {
                insert(key, value);
            }
        }
    }

    void remove(Node* node) {//移除函数
        auto pre = node->prev;
        auto nxt = node->next;
        pre->next = nxt;
        nxt->prev = pre;

        map.erase(node->key);
    }

    void insert(int key, int value) {//插入函数
        auto node = new Node(key, value);
        auto pre = head;
        auto nxt = head->next;
        pre->next = node;
        node->next = nxt;
        nxt->prev = node;
        node->prev = pre;

        map[key] = node;
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */

高频笔试题22

本文已参与「新人创作礼」活动，一起开启掘金创作之路。