力扣hot100 -- 哈希

原创已于 2024-07-27 19:39:15 修改 · 1.3k 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#力扣 #算法 #笔记

于 2024-02-08 13:44:45 首次发布

力扣 hot 100 专栏收录该内容

23 篇文章

订阅专栏

文章详细分析了LeetCode中涉及的算法问题，包括使用暴力法、二分搜索、哈希表解决两数之和，以及利用unordered_map和排序结合处理字母异位词分组和最长连续序列。同时讨论了不同方法的时间复杂度和优化技巧。

🌼两数之和

1. 两数之和 - 力扣（LeetCode）

暴力

O(n^2) 两层循环

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) { // 返回vector数组
        int n = nums.size();
        for (int i = 0; i < n - 1; ++i)
            for (int j = i + 1; j < n; ++j) 
                if (nums[i] + nums[j] == target)    
                    return {i, j};
        return {}; // 返回空数组
    }
};

二分

O(nlogn)

排序 O(nlogn)

遍历 O(nlogn) = 外层 O(n) + 二分O(logn)

AC 代码

struct node {
    int v, x; // value, index
}a[10010];

bool cmp(node x, node y) {
    return x.v < y.v; // value 从小到大
}

class Solution {
public:

    vector<int> twoSum(vector<int>& nums, int target) {
        int n = nums.size();
        for (int i = 0; i < n; ++i)
            a[i].x = i, a[i].v = nums[i];
        sort(a, a + n, cmp); // v,x 保留原来元素和索引的一一对应关系

        for (int i = 0; i < n - 1; ++i) {
            int l = i + 1, r = n - 1; // i 的下一个位置开始二分
            while (l < r) {
                int m = (l + r + 1) >> 1; // 防止 l 不变，死循环
                if (a[m].v + a[i].v > target)
                    r = m - 1;
                else
                    l = m; 
            }
            if (a[i].v + a[l].v == target)
                return {a[i].x, a[l].x};
        }
        return {}; // 空数组
    }
};

哈希

O(n)

知识

map<string, int>a; //升序
map<string, int, greater<string> >a; //降序

h[key] = val;
//等价于
h.insert(make_pair(key, val));

for(map<string, int>::iterator it = a.begin(); it != a.end(); ++it)
    cout<<it->first<<"\t"<<it->second<<endl;

size/empty/clear //元素个数，判空，清空
begin / end //指向开始 / 结束位置的指针
insert(x) //将元素x插入集合(x为二元组)
erase(x) //删除所有等于x的元素(x为二元组)
erase(it) //删除it指向的元素(it为指向二元组的迭代器)
find(k) //查找键为k的二元组的位置, 若不存在, 返回尾指针 .end()

C++ map和unordered_map详解-腾讯云开发者社区-腾讯云 (tencent.com)

AC 代码

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) { // 返回vector数组
        int n = nums.size();
        unordered_map<int, int> h; // 键 元素大小；值 元素下标
        for (int i = 0; i < n; ++i) {
            auto it = h.find(target - nums[i]); // 查找这个键 -- 元素大小
            if (it != h.end()) // 找到了该元素
                return {i, it->second}; // 返回下标

            //h.insert(make_pair(nums[i], i)); // 插入键值对
            h[nums[i]] = i; // 插入键值对
        }
        return {}; // 返回空数组
    }
};

🌼字母异位词分组

49. 字母异位词分组 - 力扣（LeetCode）

知识

1）emplace_back 与 push_back

一文弄清楚 push_back 和 emplace_back 的区别-emplace_back和push_back有区别吗 (51cto.com)

2）unordered_map 与 map

map和unordered_map区别及其优缺点 - 己平事 - 博客园 (cnblogs.com)

map、multimap 容器都会自行根据键的大小对存储的键值对进行排序

3）代码中，两个要注意的点

（一）引用传递比迭代器快很多（访问vector<string>时）
// 引用传递
for (string& str : strs) 

// 迭代器
for (vector<string>::iterator it = strs.begin(); it != strs.end(); ++it)
（二）emplace_back 比 push_back 快 20%

unordered_map + 排序

O(n*k*logk) n -- strs中字符串数量 k 单个字符串最大长度 ≈ 5*1e6

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string> > s; // 键 string  值 vector<string>
        vector<vector<string> > ans; // 返回类型

        // 遍历字符串数组 strs
        for (string& str : strs) { // 引用传递 快很多
            string key = str;
            sort(key.begin(), key.end());
            s[key].push_back(str);
        }
        // for (vector<string>::iterator it = strs.begin(); it != strs.end(); ++it) {
        //     string key = *it; // 键
        //     sort(key.begin(), key.end()); // 对键排序
        //     s[key].push_back(*it); // 键 -- 排序后的值
        // }

        for (auto t : s) 
            ans.push_back(t.second); // 插入vector<string>类型数组
        // for (auto it = s.begin(); it != s.end(); ++it)
        //     ans.push_back(it->second);

        return ans;
    }
};

unordered_map + 计数

O(n*k)

排序 --> 计数，变相得到了每个字符串按字典序的排序（隐含的是：int 和 char 之间的

隐式转换

注意：& 比不用&，快很多，避免将元素的值复制到新的变量中

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        // 键，strs中已排序字符串--temp
        // 值，strs中对应的字母异位词--vector<string>
        unordered_map<string, vector<string>> hash;
        vector<vector<string>> ans;
        for (auto s : strs) {
            string temp(26, '='); // 字符字面量--随便初始化，不为''就行
            for (auto c : s) 
                temp[c - 'a']++; // 每个字符出现次数，记录在字符串 temp 中
            hash[temp].push_back(s); // 键是temp, 值是vector<string>, s 插到值里面
        }
        for (auto s : hash)
            ans.push_back(s.second); // s.second 就是值, 也就是 vector<string>
        return ans;
    }
};

🌼最长连续序列

128. 最长连续序列 - 力扣（LeetCode）

知识

size/empty/clear //元素个数  判空  清空
begin/end //开始和结束位置
inset(x) //元素x插入集合
erase(x) //删除所有值为x的元素
erase(it) //删除it迭代器指向的元素
find(x) //查找x在集合的位置，不存在则返回end
count(x) //统计x元素的个数
lower_bound(x) //返回大于等于x的最小元素位置
upper_bound(x) //返回大于x的最小元素位置

思路

set 用于去重

unordered_set，不需要有序，所以用 unordered

存在前驱则跳过

unordered_set + 跳过前驱

O(n)

外层循环 for，因为“存在前驱，则跳过”，数组中每个数，只会进入内层 while 循环 1 次

所以外层 O(n)，内层 O(1)

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {

        int ans = 0; // 初始0 有可能空数组

        unordered_set<int> s; // 去重
        for (const int& num : nums) // 引用传递
            s.insert(num);

        for (auto& num : s) { // 遍历哈希表

            if (s.count(num - 1)) continue; // 存在前驱 -- 跳过当前

            int currentNum = num, currentLen = 1; // 当前长度 1
            while (s.count(currentNum + 1)) {
                currentLen++; // 长度 +1
                currentNum++; // 值 +1
            }
            ans = max(ans, currentLen);
        }
        return ans;
    }
};

排序 + dp

很好奇，为什么 O(nlogn) 的复杂度，要比上面的 O(n) 快得多........

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        if (!nums.size()) return 0; // 避免空数组

        sort(nums.begin(), nums.end()); // 先排序

        vector<int> nums2;
        nums2.push_back(nums[0]);
        for (int i = 1; i < nums.size(); ++i) 
            if (nums[i] != nums[i - 1]) // 再去重
                nums2.push_back(nums[i]); 
        
        int n = nums2.size(), ans = 1;
        if (n == 0) return 0; // 避免空数组
        vector<int> dp(n, 1); // 初始化
        for (int i = 1; i < n; ++i) {
            if (nums2[i] == nums2[i - 1] + 1)
                dp[i] = dp[i - 1] + 1;
            ans = max(ans, dp[i]);
        }
        return ans;
    }
};

/*
含义：dp[i] 以第 i 个数结尾的最大长度（下标 0 开始）
递推式：if (nums[i] == nums[i - 1] + 1) dp[i] = dp[i - 1] + 1;
初始化：dp[0...n-1] = 1
遍历顺序：nums[]  0...n-1
打表检查
*/