unordered_map 是C++标准模板库（STL）中的关联容器，在 <unordered_map> 头文件中，位于 std 命名空间 。以下是它的详细介绍：

特性

• 关联性：以键值对（pair 类型）形式存储数据 ，通过键快速检索对应的值，而非像顺序容器那样通过绝对地址访问 。例如 unordered_map<string, int> umap; ，可通过字符串键找对应的整数值 。
• 无序性：内部采用哈希表存储结构 ，元素不会按键值或映射值的特定顺序排序 。区别于 map （内部用红黑树实现，元素有序） 。
• 键唯一性：键不能重复，不存在两个键相同的元素 。
• 动态内存管理：利用内存管理模型动态分配和管理内存空间 。

工作原理

借助哈希函数，把键映射到哈希桶（数组中的位置） 。插入新键值对时，计算键的哈希值确定桶，然后将键值对存于该桶 。查找键时，同样先算哈希值定位桶，再在桶内找目标键 。因不同键可能哈希到同一桶（哈希冲突），桶内常以链表或红黑树等结构组织元素 。

常用操作

• 插入元素：可使用 insert 成员函数 ，如 umap.insert({ "key", 1 }); ；也能用 [] 操作符，像 umap["key"] = 1; （若键不存在则插入新键值对，存在则更新值 ） 。
• 访问元素：通过 [] 操作符或 at 成员函数 ，如 int value = umap["key"]; ，at 函数在键不存在时会抛 out_of_range 异常 。
• 查找元素：用 find 成员函数 ，如 auto it = umap.find("key"); ，找到返回指向元素的迭代器，否则返回 end() 迭代器 。
• 删除元素：可按键删除，如 umap.erase("key"); ；也能按迭代器指定位置或范围删除 。
• 其他操作：size 函数获取元素个数 ，empty 函数判断容器是否为空 ，clear 函数清空容器等 。

构造方式

• 默认构造：std::unordered_map<key_type, value_type> umap;
• 初始化列表构造：std::unordered_map<std::string, int> umap = { { "one", 1 }, { "two", 2 } };
• 拷贝构造：std::unordered_map<std::string, int> umap2(umap); （umap 为同类型容器 ）

优缺点

• 优点： 平均情况下，查找、插入和删除操作时间复杂度为 $O(1)$ ，数据量大时效率优势明显；可自定义哈希函数优化查找 。
• 缺点：哈希表构建较耗时；因哈希冲突和额外存储结构（如链表） ，空间占用可能比一些有序容器大；元素无顺序，对有序性有要求场景不适用 。

适用场景

适用于无需元素有序，更看重快速查找、插入和删除操作的场景 。如缓存系统（快速查找缓存数据 ） 、统计单词出现次数（快速插入和更新计数 ） 、实现哈希表相关功能等 。

用C++实现一个程序，对给定的正整数进行唯一分解

#include <iostream>
#include <vector>
using namespace std;

// 对正整数进行唯一分解
vector<pair<int, int>> primeFactorization(int n) {
    vector<pair<int, int>> factors;
    for (int i = 2; i * i <= n; ++i) {
        int exponent = 0;
        while (n % i == 0) {
            n /= i;
            ++exponent;
        }
        if (exponent > 0) {
            factors.emplace_back(i, exponent);
        }
    }
    if (n > 1) {
        factors.emplace_back(n, 1);
    }
    return factors;
}

int main() {
    int num;
    cout << "请输入一个正整数: ";
    cin >> num;

    auto result = primeFactorization(num);

    cout << num << " 的唯一分解形式为: ";
    for (size_t i = 0; i < result.size(); ++i) {
        cout << result[i].first;
        if (result[i].second > 1) {
            cout << "^" << result[i].second;
        }
        if (i < result.size() - 1) {
            cout << " * ";
        }
    }
    cout << endl;

    return 0;
}    

你已经给出了部分代码，下面我会基于你给出的头文件和命名空间，补全代码实现对给定正整数进行唯一分解的功能。

代码解释

1. primeFactorization 函数：
   • 该函数接收一个正整数 n 作为参数，返回一个 vector<pair<int, int>> 类型的结果，其中每个 pair 存储一个质因数及其对应的指数。
   • 从最小的质数 2 开始，通过循环 for (int i = 2; i * i <= n; ++i) 来尝试将 n 分解。对于每个可能的质因数 i，使用 while 循环计算其在 n 中的指数 exponent。
   • 如果 exponent 大于 0，说明 i 是 n 的一个质因数，将其和对应的指数作为一个 pair 存入 factors 中。
   • 当循环结束后，如果 n 仍然大于 1，说明 n 本身是一个质数，将其作为一个质因数存入 factors 中，指数为 1。
2. main 函数：
   • 提示用户输入一个正整数，并将其存储在变量 num 中。
   • 调用 primeFactorization 函数对 num 进行分解，将结果存储在 result 中。
   • 遍历 result，按照质因数和指数的格式输出分解结果，不同质因数之间用 * 连接。

复杂度分析

二、C++ 实现以下是用 C++ 实现对整数进行质因数分解（基于唯一分解定理）的代码：

#include <iostream>
#include <unordered_map>
// 函数用于对整数进行质因数分解
std::unordered_map<int, int> primeFactorization(int n) {
    std::unordered_map<int, int> factors;
    for (int i = 2; i * i <= n; ++i) {
        while (n % i == 0) {
            factors[i]++;
            n /= i;
        }
    }
    if (n > 1) {
        factors[n] = 1;
    }
    return factors;
}
int main() {
    int num = 24;
    auto factors = primeFactorization(num);
    std::cout << num << " 的质因数分解结果为：";
    for (const auto& factor : factors) {
        if (factor.second > 1) {
            std::cout << factor.first << "^" << factor.second << " ";
        } else {
            std::cout << factor.first << " ";
        }
    }
    std::cout << std::endl;
    return 0;
}