设计哈希映射

第一种直接用数组的方法就不写了。

第二种是用一个二维数组，减小数组的稀疏空间，也不写了。

第三种是用hash链表数组，关键是注意指针节点是否为空和二级指针的使用。

(由于一个remove没有写return 导致我删除节点后访问了空节点，debug一个小时，掏出了文本对比器，非常无语。。。)

struct node
{
    int key, val;
    node *next;
    node() : key(-1), val(-1), next(nullptr) {}
    node(int k, int v) : key(k), val(v), next(nullptr) {}
};
class MyHashMap
{
    int N = 2022;
    vector<node *> num;

public:
    MyHashMap()
    {
        num = vector<node *>(N);
    }
    int gethashkey(int key)
    {
        return key % N;
    }
    void put(int key, int value)
    {
        auto k = gethashkey(key);
        auto &n = num[k], p = n, pre = p;
        if (n == nullptr)
        {
            n = new node(key, value);
            return;
        }
        while (p)
        {
            if (p->key == key)
            {
                p->val = value;
                return;
            }
            pre = p;
            p = p->next;
        }
        pre->next = new node(key, value);
    }
    int get(int key)
    {
        auto k = gethashkey(key);
        auto n = num[k], p = n;
        if (n == nullptr)
            return -1;
        while (p)
        {
            if (p->key == key)
                return p->val;
            p = p->next;
        }
        return -1;
    }
    void remove(int key)
    {
        auto k = gethashkey(key);
        auto &n = num[k], p = n;
        if (n == nullptr)
            return;
        node *pre = nullptr;
        while (p)
        {
            if (p->key == key)
            {
                if (pre)
                {
                    pre->next = p->next;
                    p->next = nullptr;
                    delete p;
                }
                else
                {
                    auto now = n;
                    n = n->next;
                    now->next = nullptr;
                    delete now;
                }
                return;
            }
            pre = p;
            p = p->next;
        }
    }
};

 

搜索

复制