Hash专场

没什么..

已于 2022-04-17 17:57:32 修改

阅读量314

点赞数

分类专栏：牛客网&&LeetCode中好的题文章标签：哈希算法散列表

于 2021-12-26 19:27:34 首次发布

本文链接：https://blog.csdn.net/MEANSWER/article/details/122158394

版权

牛客网&&LeetCode中好的题专栏收录该内容

55 篇文章 0 订阅

订阅专栏

Hash专场

1. LeetCode第705题---设计哈希集合
2. LeetCode第706题---设计哈希映射
3. LeetCode第49题---字母异位词分组
4. LeetCode第13题---罗马数字转整数
5. LeetCode第12题---整数转罗马数字
5. LeetCode第599题---两个列表的最小索引总和
6. LeetCode第506题---相对名次
7. LeetCode41题---缺失的第一个正数

1. LeetCode第705题—设计哈希集合

链接: https://leetcode-cn.com/problems/design-hashset/
在这里插入图片描述
解题思路：使用数组 + 单链表的形式

class MyHashSet {
    struct Node{
        int val;
        Node* next;
        Node(int key):val(key),next(nullptr)
        {}
    };
public:
    MyHashSet() {
        bucket.resize(keyRange,nullptr);
    }
    
    //数组中存放的是链表的第一个头节点
    void add(int key) {
        int index = hash(key);
        if(bucket[index] == nullptr)
        {
            bucket[index] = new Node(key);
            return;
        }
        //走到这里说明不是空，那就需要看看是否已经有这个值了
        auto tmp = bucket[index];
        if(tmp->val == key)
            return;
        //走到这里就说明第一个节点不是
        while(tmp->next)
        {
            if(tmp->next->val == key)
            {
                return;
            }
            tmp = tmp->next;
        }
        //走到这里说明全部都已经在该链表中找完了，但是还是没有找到
        tmp->next = new Node(key);
    }
    
    void remove(int key) {
        int index = hash(key);
        if(bucket[index] == nullptr)
            return;
        Node* tmp = bucket[index];
        if(tmp->val == key)
        {
            bucket[index] = tmp->next;
            delete tmp;
        }
        else
        {
            Node* next = tmp->next;
            while(next)
            {
                if(next->val == key)
                {
                    tmp->next = next->next;
                    delete next;
                    break;   
                }
                tmp = next;
                next = next->next;
            }
        }
    }
    
    bool contains(int key) {
        bool result = false;
        int index = hash(key);
        Node* node = bucket[index];
        while (node) {
            if (node->val == key) {
                result = true;
                break;
            }
            node = node->next;
        }
        return result;
    }
private:
    int hash(int key)
    {
        return (key % keyRange);
    }
    int keyRange = 31;
    vector<Node*> bucket;
};

2. LeetCode第706题—设计哈希映射

链接: https://leetcode-cn.com/problems/design-hashset/
在这里插入图片描述

class MyHashMap {
private:
    struct Node {
        int key;
        int value;
        Node *next;
        Node(int key, int value) : key(key), value(value), next(nullptr) {}
    };

public:
    /** Initialize your data structure here. */
    MyHashMap() {
        bucket.resize(keyRange,nullptr);
    }
    
    /** value will always be non-negative. */
    void put(int key, int value) {
        int index = hash(key);
        if (bucket[index] == nullptr) {
            bucket[index] = new Node(key, value);
            return;
        }
        auto node = bucket[index];
        if (node->key == key) {
            node->value = value;
            return;
        }
        while (node->next) {
            if (node->next->key == key) {
                node->next->value = value;
                return;
            }
            node = node->next;
        }
        node->next = new Node(key, value);
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    int get(int key) {
        int index = hash(key);
        if (bucket[index] == nullptr) {
            return -1;
        }
        auto node = bucket[index];
        if (node->key == key) {
            return node->value;
        }
        while (node->next) {
            if (node->next->key == key) {
                return node->next->value;
            }
            node = node->next;
        }
        return -1;
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    void remove(int key) {
        int index = hash(key);
        if (bucket[index] == nullptr) {
            return;
        }
        auto node = bucket[index];
        if (node->key == key) {
            bucket[index] = node->next;
            delete node;
            return;
        }
        auto next = node->next;
        while (next) {
            if (next->key == key) {
                node->next = next->next;
                delete next;
                return;
            }
            node = next;
            next = next->next;
        }
    }

private:
    int hash(int key) {
        return (key % keyRange);
    }

    int keyRange = 31;
    vector<Node *> bucket;
};

3. LeetCode第49题—字母异位词分组

在这里插入图片描述
解题思路：虽然这里有很多的字符串，但是我们给他排序了以后，给他分到专属于他的数组后，就能得到我们想要的结果。

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        //虽然说每一个小字符串的顺序是各不相同的，但是我们给他们都排一个序以后就会发现，其实顺序是相同的
        unordered_map<string,vector<string>> hashmap;
        vector<vector<string>> vv;
        for(auto& str : strs)
        {
            string key = str;
            sort(key.begin(),key.end());
            hashmap[key].push_back(str);
        }
        //此时我需要把同一组的vector<string>都插入到我定义的vv中
        //如果按照这个想法写下去，那他妈就得被面试官笑死，什么玩意呀？
        //使用迭代器的方式是最好的
        auto it = hashmap.begin();
        while(it != hashmap.end())
        {
            vv.push_back(it->second);
            ++it;
        }
        return vv;
    }
};

4. LeetCode第13题—罗马数字转整数

在这里插入图片描述

class Solution {
public:
    int romanToInt(string s) {
        unordered_map<char,int> hashmap{{'I',1},{'V',5},{'X',10},{'L',50},{'C',100},{'D',500},{'M',1000}};
        //这道题简单点说就是如果前一个数壁厚一个药效，那么就需要减掉，如果前一个比后一个要大就要加上这个值
        int res = 0;
        int n = s.size();
        for(int i = 0;i<n;++i)
        {
            int val = hashmap[s[i]];
            if(i < n-1 && val < hashmap[s[i+1]])
                res -= val;
            else
                res += val;
        }
        return res;
    }
};

5. LeetCode第12题—整数转罗马数字

在这里插入图片描述
这道题使用unordered_map方法肯定是不好的，最好的就是使用pair这样的关联对，我们在整数转罗马数字的时候，我们尽可能的要使用最大最贴近答案的数来进行一步步的转换

class Solution {
public:
    string intToRoman(int num) {
        //如果我们只是单纯的要那个数，你会发现其实我们能够进行组合的数简直不要太多，但是我们不能够这样
        //最好的方法我们应该使用从大到小的顺序进行排序
        const pair<int,string> NumSymbol[] = {{1000,"M"},{900,"CM"},{500,"D"},{400,"CD"},{100,"C"},{90,"XC"},{50,"L"},{40,"XL"},{10,"X"},{9,"IX"},{5,"V"},{4,"IV"},{1,"I"}};
        string str;
        for(auto& e : NumSymbol)
        {
            //3作为示例
            while(num >= e.first)
            {
                num -= e.first;
                str += e.second;
            }
            //一但num为0了也不要在继续进行下去了，没有意义在遍历后面的数了
            if(num == 0)
                break;
        }
        return str;
    }
};

5. LeetCode第599题—两个列表的最小索引总和

在这里插入图片描述

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        int m = list1.size();
        int n = list2.size();
        vector<string> res;
        int min = INT_MAX;
        unordered_map<string,int> hashmap;
        for(int i = 0;i<m;++i)
        {
            hashmap[list1[i]] = i;
        }
        for(int i = 0;i<n;++i)
        {
            string str = list2[i];
            if(hashmap.find(str) == hashmap.end())
            {
                continue;
            }
            else
            {
                if(i + hashmap[str] < min)
                {
                    res.clear();
                    min = i + hashmap[str];
                    res.push_back(str);
                }
                else if(i + hashmap[str] == min)
                {
                    res.push_back(str);
                }
            }
        }
        return res;
    }
};

6. LeetCode第506题—相对名次

在这里插入图片描述

class Solution {
public:
    //这道题挺有意思的，等会可以在做一次
    vector<string> findRelativeRanks(vector<int>& score) {
        int n = score.size();
        vector<pair<int,int>> v;
        for(int i = 0;i<n;++i)
            v.push_back(make_pair(score[i],i));
        //sort本身是按照分数上升进行的排序
        sort(v.begin(),v.end(),[](const pair<int,int>& a,const pair<int,int>& b){
            return a.first > b.first;
        });
        vector<string> res(n);
        for(int i = 0;i<n;++i)
        {
            if(i == 0)
                res[v[0].second] = "Gold Medal";
            else if(i == 1)
                res[v[1].second] = "Silver Medal";
            else if(i == 2)
                res[v[2].second] = "Bronze Medal";
            else
                res[v[i].second] = to_string(i+1);
        }
        return res;
    }
};

7. LeetCode41题—缺失的第一个正数

在这里插入图片描述
我们把数组本身看作是哈希表，也叫做原地哈希法。我们需要把每个元素值配位，每个元素应该待在对应的值-1的数组下标位置处，比如说3，那么他应该呆在数组下标为2的位置上。这道题当然也可以使用hash的方法，因为每一个数肯定就是在[1,length]中的一个，但是这个需要O(N)的空间复杂度

class Solution {
public:
    //使用哈希表的方式，先将所有的数进行隐射，然后从[1,N]去找缺失的第一个正数，但是空间复杂度是不符合条件的
    //将数组本身看成哈希表，将数值i放在i-1的下标上
    int firstMissingPositive(vector<int>& nums) {
        int n = nums.size();
        for(int i = 0;i<n;++i)
        {
            //因为即使交换完毕以后，依旧可能出现值不配位
            while(nums[i] != i + 1)
            {
                if(nums[i] <= 0 || nums[i] > n || nums[i] == nums[nums[i]-1])
                    break;
                //真正因该呆的下标
                int index = nums[i]-1;
                swap(nums[i],nums[index]);
            }
        }
        for(int i = 0;i<n;++i)
        {
            if(nums[i] != i+1)
                return i+1;
        }
        //此时全部都已经遍历过了，也没有发现不对劲的，所以这个就是缺失的最后一个
        return n + 1;
    }
};