leetcode202 快乐数哈希结构集合-优快云博客

本文链接：https://blog.youkuaiyun.com/dokii1/article/details/146019794

重点是在“无限循环”上。

什么叫循环，循环就是出现了一遍又一遍，如果循环了那肯定就不是快乐数。

那这道题就可以转化成：【在“将正整数替换为它每个位置上的数字的平方和”过程中，新出现的正整数是否曾经出现过。】记录出现过的正整数，然后将新元素与之前出现过的正整数比较。

碰到这种对目前来说是未知数量和未知数值大小的情况，我们可以使用集合 set 来解决。

在算法问题中，经常会遇到“未知数值大小”的情况，尤其是当我们需要动态地存储和检查某些数值是否出现过时。使用集合（set 或 unordered_set）是一种非常有效的方法，原因如下：

1. 集合的核心特性

集合（set 或 unordered_set）是一种存储唯一元素的数据结构，具有以下特性：

唯一性：集合中的元素是唯一的，不会重复。

快速查找：集合的查找操作非常高效：

set 的查找时间复杂度为 O(log⁡n)O(logn)。

unordered_set 的查找平均时间复杂度为 O(1)O(1)。

动态扩展：集合可以动态地插入和删除元素，适合处理未知大小的数据。

这些特性使得集合非常适合用于解决需要动态存储和检查元素是否存在的问题。

2. 为什么集合适合处理未知数值大小的情况？

在算法问题中，经常会遇到以下场景：

数值范围未知：我们不知道数值的大小范围，或者数值的范围非常大（例如，数值可能是一个很大的整数）。

动态变化：数值是动态生成的，无法预先确定。

需要快速检查：我们需要快速检查某个数值是否已经出现过。

集合的特性正好满足这些需求：

动态插入：集合可以动态地插入新元素，无需预先分配空间。

快速查找：集合可以快速检查某个数值是否已经存在。

空间效率：集合只存储唯一的元素，避免了重复数据的存储。

3. 集合的应用场景

以下是一些典型的应用场景，说明为什么集合适合处理未知数值大小的情况：

（1）检测循环
问题：在“快乐数”问题中，我们需要检测是否进入了循环（即某个数值是否重复出现）。

解决方法：使用集合存储已经出现过的数值，每次生成新数值时检查是否已经存在于集合中。
代码示例：

cpp

复制
unordered_set<int> seen;
while (n != 1) {
    if (seen.find(n) != seen.end()) {
        return false; // 检测到循环
    }
    seen.insert(n);
    n = GetSquareSum(n); // 生成下一个数值
}
return true;
（2）去重
问题：在一个动态生成的数值序列中，我们需要去除重复的数值。

解决方法：使用集合存储数值，集合会自动去重。
代码示例：

cpp

复制
vector<int> nums = {1, 2, 2, 3, 4, 4, 5};
unordered_set<int> uniqueNums(nums.begin(), nums.end());
for (int num : uniqueNums) {
    cout << num << " "; // 输出：1 2 3 4 5
}
（3）快速查找
问题：在一个动态生成的数值序列中，我们需要快速检查某个数值是否存在。

解决方法：使用集合存储数值，利用集合的快速查找特性。
代码示例：

cpp

复制
unordered_set<int> nums = {1, 2, 3, 4, 5};
if (nums.find(3) != nums.end()) {
    cout << "3 exists!" << endl;
}
4. 集合的优势

灵活性：集合可以动态地处理未知大小的数据，无需预先分配空间。

高效性：集合的查找和插入操作非常高效，适合需要频繁检查的场景。

简洁性：使用集合可以简化代码逻辑，避免手动实现复杂的查找和去重逻辑。

5. 集合的选择：set vs unordered_set

set：

基于红黑树实现，元素是有序的。

查找、插入和删除的时间复杂度为 O(log⁡n)O(logn)。

适合需要有序存储的场景。

unordered_set：

基于哈希表实现，元素是无序的。

查找、插入和删除的平均时间复杂度为 O(1)O(1)。

适合需要快速查找且不关心顺序的场景。

在大多数情况下，如果不需要有序性，优先选择 unordered_set，因为它的性能更高。

总结

集合（set 或 unordered_set）非常适合处理未知数值大小的情况，因为它可以动态地存储和检查元素。

集合的核心特性（唯一性、快速查找、动态扩展）使其成为解决这类问题的理想选择。

根据具体需求选择合适的集合类型（set 或 unordered_set）。

将当前数进行数位分离，求各位上平方的和。
每次生成的数，查是否在哈希集合中，在的话就不是快乐数，不在的话就添到集合里。

和 map、multimap 容器不同，使用 set 容器存储的各个键值对，要求键 key 和值 value 必须相等。map、multimap 容器都会自行根据键的大小对存储的键值对进行排序，set 容器也会如此，只不过 set 容器中各键值对的键 key 和值 value 是相等的，根据 key 排序，也就等价为根据 value 排序。

使用 set 容器存储的各个元素的值必须各不相同。更重要的是，从语法上讲 set 容器并没有强制对存储元素的类型做 const 修饰，即 set 容器中存储的元素的值是可以修改的。但是，C++ 标准为了防止用户修改容器中元素的值，对所有可能会实现此操作的行为做了限制，使得在正常情况下，用户是无法做到修改 set 容器中元素的值的。

class Solution {
public:
    int GetIntNum(int n){
        int sum = 0;
        while(n){
            int u = n % 10;
            sum += u * u;
            n /= 10;
        }
        return sum;
    }

    bool isHappy(int n) {
        set<int> HappyNum;
        while(n != 1){
            if(HappyNum.find(n) != HappyNum.end()){
                return false;
            }
            HappyNum.insert(n);
            n = GetIntNum(n);
        }
        return true;  
    }
};

set查找元素：.find()函数，如果找到元素，则返回指向该元素的迭代器，否则返回指向集合末尾的迭代器，即set :: end()。

使用 unordered_set 来判断 sum 是否重复出现是一个更好的选择，因为 unordered_set 的查找和插入操作的平均时间复杂度是 O(1)O(1)，而 set 的查找和插入操作的时间复杂度是 O(log⁡n)O(logn)。因此，使用 unordered_set 可以提高代码的效率。

unordered_set 和 set 都是 C++ 标准库中的容器，用于存储唯一元素，但它们的底层实现和性能特点不同：

set：

基于红黑树（一种平衡二叉搜索树）实现。

元素是有序的（默认按升序排列）。

查找、插入和删除操作的时间复杂度为 O(log⁡n)O(logn)。

适合需要有序存储的场景。

unordered_set：

基于哈希表实现。

元素是无序的。

查找、插入和删除操作的平均时间复杂度为 O(1)O(1)，最坏情况下为 O(n)O(n)（哈希冲突较多时）。

适合需要快速查找和插入的场景。

在判断“快乐数”时，我们需要频繁地查找和插入数字，而元素的顺序并不重要。因此，使用 unordered_set 可以显著提高性能，尤其是在数据量较大时。

map 是 C++ 标准库中的一种关联容器，用于存储键值对（key-value pairs）。它的底层实现通常是红黑树（一种平衡二叉搜索树），因此元素是有序的（默认按键的升序排列）。map 的主要特点是：

有序性：元素按照键的顺序存储。

唯一性：每个键只能出现一次。

查找效率：查找、插入和删除操作的时间复杂度为 O(log⁡n)O(logn)。

map 的使用场景通常包括以下几种：

1. 需要键值对映射的场景
当你需要将一个键（key）映射到一个值（value）时，map 是一个很好的选择。
例如，统计单词出现的次数：

cpp

复制
map<string, int> wordCount;
wordCount["apple"] = 5;
wordCount["banana"] = 3;
这里，map 将单词（键）映射到它的出现次数（值）。
2. 需要有序键的场景
map 中的元素是按照键的顺序存储的，因此如果你需要按键的顺序遍历或访问元素，map 是一个合适的选择。
例如，存储学生的成绩并按学号排序：

cpp

复制
map<int, int> studentScores;
studentScores[1001] = 90;
studentScores[1002] = 85;
studentScores[1003] = 95;
这里，map 会按照学号（键）的升序存储学生的成绩。
3. 需要快速查找键的场景
map 的查找操作时间复杂度为 O(log⁡n)O(logn)，适合需要频繁查找键的场景。
例如，查找某个学生的成绩：

cpp

复制
if (studentScores.find(1001) != studentScores.end()) {
    cout << "Score: " << studentScores[1001] << endl;
}
4. 需要唯一键的场景
map 中的键是唯一的，因此如果你需要确保键的唯一性，map 是一个很好的选择。
例如，存储用户的唯一 ID 和对应的信息：

cpp

复制
map<int, string> userInfo;
userInfo[101] = "Alice";
userInfo[102] = "Bob";
5. 需要范围查询的场景
由于 map 是有序的，你可以方便地进行范围查询。
例如，查找学号在 1001 到 1003 之间的学生成绩：

cpp

复制
auto low = studentScores.lower_bound(1001);
auto high = studentScores.upper_bound(1003);
for (auto it = low; it != high; ++it) {
    cout << "ID: " << it->first << ", Score: " << it->second << endl;
}
6. 与 unordered_map 的对比

map：

有序（按键排序）。

查找、插入和删除的时间复杂度为 O(log⁡n)O(logn)。

适合需要有序键或范围查询的场景。

unordered_map：

无序（基于哈希表）。

查找、插入和删除的平均时间复杂度为 O(1)O(1)。

适合需要快速查找且不关心顺序的场景。

总结

使用 map 的场景包括：

需要键值对映射。

需要有序键。

需要快速查找键。

需要唯一键。

需要范围查询。

如果你不需要有序性，且更关注查找效率，可以选择 unordered_map。