C++数据结构——Map

最新推荐文章于 2025-05-01 21:36:18 发布
最新推荐文章于 2025-05-01 21:36:18 发布
阅读量506 收藏 9
点赞数 23
分类专栏： C++数据结构 文章标签： c++ 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Daniel0429/article/details/147629834
版权

一、map 基础概念

1. 什么是 map？

map 是 C++ STL 中的关联容器，它提供基于键（key）的快速数据检索能力，具有以下特性：

  • 键值对（key-value）存储
  • 按键自动排序（默认升序）
  • 键唯一（不允许重复）
  • 基于红黑树实现（平衡二叉搜索树）

2. map 基本操作复杂度

操作时间复杂度说明
插入O(log n)需要维持树平衡
删除O(log n)需要维持树平衡
查找O(log n)二分查找
遍历O(n)需要访问所有节点
修改值O(log n)需要先查找

二、map 的基本使用

1. 头文件与声明

#include <map>
#include <string>

// 基本声明
std::map<int, std::string> studentMap;

// 使用初始化列表
std::map<std::string, double> priceMap {
    {"apple", 1.99},
    {"banana", 0.99},
    {"orange", 2.49}
};

2. 常用操作详解

(1) 插入元素
// 使用insert成员函数
auto ret = studentMap.insert({101, "Alice"});
// ret是pair<iterator, bool>，second表示是否插入成功

// 使用operator[] (如果键不存在会自动创建)
studentMap[102] = "Bob"; // 插入或修改

// 使用emplace (C++11更高效的方式)
studentMap.emplace(103, "Charlie");
(2) 访问元素
// 使用operator[] (键不存在时会创建)
std::string name = studentMap[101];

// 使用at (键不存在时抛出out_of_range异常)
try {
    std::string name = studentMap.at(101);
} catch (const std::out_of_range& e) {
    std::cerr << "Key not found: " << e.what() << std::endl;
}

// 使用find (安全访问方式)
auto it = studentMap.find(104);
if (it != studentMap.end()) {
    std::cout << "Found: " << it->second << std::endl;
} else {
    std::cout << "Key 104 not found" << std::endl;
}
(3) 删除元素
// 通过键删除
size_t numRemoved = studentMap.erase(101);

// 通过迭代器删除
auto it = studentMap.find(102);
if (it != studentMap.end()) {
    studentMap.erase(it);
}

// 删除范围 (前闭后开区间)
auto first = studentMap.find(100);
auto last = studentMap.find(200);
if (first != studentMap.end() && last != studentMap.end()) {
    studentMap.erase(first, last);
}

// 清空map
studentMap.clear();
(4) 遍历元素
// 使用迭代器
for (auto it = studentMap.begin(); it != studentMap.end(); ++it) {
    std::cout << "ID: " << it->first << ", Name: " << it->second << std::endl;
}

// 使用范围for循环 (C++11)
for (const auto& pair : studentMap) {
    std::cout << "ID: " << pair.first << ", Name: " << pair.second << std::endl;
}

// 使用结构化绑定 (C++17)
for (const auto& [id, name] : studentMap) {
    std::cout << "ID: " << id << ", Name: " << name << std::endl;
}

三、map 的高级特性

1. 自定义比较函数

// 自定义键比较函数
struct CaseInsensitiveCompare {
    bool operator()(const std::string& a, const std::string& b) const {
        return std::lexicographical_compare(
            a.begin(), a.end(),
            b.begin(), b.end(),
            [](char c1, char c2) {
                return tolower(c1) < tolower(c2);
            });
    }
};

std::map<std::string, int, CaseInsensitiveCompare> wordCountMap;

// 使用函数指针
bool compareStrings(const std::string& a, const std::string& b) {
    return a.length() < b.length();
}

std::map<std::string, int, decltype(&compareStrings)> lengthMap(&compareStrings);

2. 特殊查找操作

std::map<int, std::string> m {
    {10, "ten"},
    {20, "twenty"},
    {30, "thirty"},
    {40, "forty"}
};

// lower_bound - 第一个不小于key的元素
auto lb = m.lower_bound(25); // 指向30

// upper_bound - 第一个大于key的元素
auto ub = m.upper_bound(25); // 指向30

// equal_range - 返回匹配的范围
auto range = m.equal_range(20);
// range.first指向20，range.second指向30

3. 性能优化技巧

// 1. 使用emplace_hint提高插入效率
auto hint = m.begin(); // 可以是任何合理的迭代器位置
m.emplace_hint(hint, 15, "fifteen");

// 2. 避免不必要的拷贝
std::map<int, std::string> bigMap;
// 不好：会创建临时string
bigMap[1] = "very long string...";
// 更好：使用try_emplace (C++17)
bigMap.try_emplace(1, "very long string...");

// 3. 节点操作 (C++17)
std::map<int, std::string> source, target;
auto node = source.extract(10); // 从source移除但不销毁
if (!node.empty()) {
    target.insert(std::move(node)); // 转移到target
}

四、map 的常见易错点

1. operator[] 的陷阱

std::map<std::string, int> wordCount;

// 以下操作会插入键"unknown"并值初始化为0
int count = wordCount["unknown"]; 

// 正确做法：先检查是否存在
auto it = wordCount.find("unknown");
if (it != wordCount.end()) {
    count = it->second;
}

2. 迭代器失效问题

std::map<int, int> m {{1, 10}, {2, 20}};

// 安全：删除当前迭代器指向的元素
for (auto it = m.begin(); it != m.end(); ) {
    if (it->second == 10) {
        it = m.erase(it); // C++11后erase返回下一个有效迭代器
    } else {
        ++it;
    }
}

// 危险：在遍历时插入元素可能导致树重新平衡，使迭代器失效

3. 自定义比较函数的严格要求

// 错误的比较函数：不满足严格弱序
struct BadCompare {
    bool operator()(int a, int b) const {
        return a <= b; // 错误！应该使用 <
    }
};

// 使用这种比较函数会导致未定义行为
std::map<int, int, BadCompare> badMap;

五、map 与其他容器的比较

1. map vs unordered_map

特性mapunordered_map
实现方式红黑树哈希表
元素顺序按键排序无序
查找复杂度O(log n)平均O(1)，最差O(n)
内存使用通常较少通常较多（有负载因子）
适用场景需要有序遍历只需快速查找

2. map vs multimap

特性mapmultimap
键唯一性键唯一允许重复键
插入操作operator[]可用无operator[]
查找结果返回单个元素可能返回多个元素

六、实际应用案例

1. 单词统计

std::map<std::string, int> wordCount;
std::string word;

while (std::cin >> word) {
    // 使用operator[]会自动初始化新键为0
    ++wordCount[word];
}

// 输出统计结果（已按字典序排序）
for (const auto& [word, count] : wordCount) {
    std::cout << word << ": " << count << std::endl;
}

2. 学生成绩管理系统

class StudentGradeSystem {
private:
    std::map<int, std::map<std::string, double>> studentGrades;
    // 外层key: 学生ID
    // 内层map: 课程名 -> 成绩

public:
    void addGrade(int studentId, const std::string& course, double grade) {
        studentGrades[studentId][course] = grade;
    }

    double getGrade(int studentId, const std::string& course) const {
        auto studentIt = studentGrades.find(studentId);
        if (studentIt == studentGrades.end()) {
            throw std::runtime_error("Student not found");
        }

        auto courseIt = studentIt->second.find(course);
        if (courseIt == studentIt->second.end()) {
            throw std::runtime_error("Course not found for student");
        }

        return courseIt->second;
    }

    void printAllGrades() const {
        for (const auto& [id, courses] : studentGrades) {
            std::cout << "Student ID: " << id << "\n";
            for (const auto& [course, grade] : courses) {
                std::cout << "  " << course << ": " << grade << "\n";
            }
        }
    }
};

3. 区间映射（处理重叠区间）

class IntervalMap {
private:
    std::map<int, char> intervals; // key: 区间起点, value: 区间值

public:
    void addInterval(int start, int end, char value) {
        if (start >= end) return;

        // 删除或截断重叠区间
        auto it = intervals.upper_bound(start);
        if (it != intervals.begin()) {
            --it;
            if (it->second == value) {
                start = std::min(start, it->first);
            } else if (it->first + 1 > start) {
                // 截断现有区间
                intervals[start] = it->second;
                intervals[it->first] = it->second;
            }
            ++it;
        }

        // 处理结束部分
        while (it != intervals.end() && it->first < end) {
            if (it->second == value) {
                end = std::max(end, it->first + 1);
            } else {
                if (it->first + 1 > end) {
                    intervals[end] = it->second;
                }
            }
            it = intervals.erase(it);
        }

        intervals[start] = value;
    }

    char getValue(int point) const {
        auto it = intervals.upper_bound(point);
        if (it == intervals.begin()) {
            return '\0'; // 默认值
        }
        --it;
        return it->second;
    }
};

七、C++17/20 新特性

1. try_emplace 和 insert_or_assign

std::map<int, std::string> m;

// try_emplace: 键不存在时才构造值
m.try_emplace(1, "one"); // 构造"one"
m.try_emplace(1, "uno"); // 无效果

// insert_or_assign: 插入或更新
m.insert_or_assign(1, "uno"); // 更新为"uno"

2. 节点操作

std::map<int, std::string> source, target;

// 从source提取节点（不分配/释放内存）
auto node = source.extract(1);

if (!node.empty()) {
    // 修改键
    node.key() = 2;
    
    // 插入到target
    target.insert(std::move(node));
}

3. contains 方法 (C++20)

std::map<int, std::string> m {{1, "one"}};

if (m.contains(1)) {
    std::cout << "Key 1 exists\n";
}

八、最佳实践总结

  1. 选择正确的容器：

    • 需要有序遍历 → map
    • 只需快速查找 → unordered_map
    • 允许重复键 → multimap

  2. 安全访问：

    • 优先使用 find + 检查 end()
    • 慎用 operator[]（可能意外插入）
    • 使用 at() 进行带边界检查的访问

  3. 性能考虑：

    • 批量插入时使用 emplace_hint
    • C++17+ 使用节点操作避免拷贝
    • 自定义比较函数要满足严格弱序

  4. 现代C++特性：

    • 使用 try_emplace 避免不必要的临时对象
    • 使用结构化绑定简化遍历代码
    • C++20 使用 contains 替代 find + end 检查

  5. 线程安全：

    • map 本身不是线程安全的
    • 多线程环境需要外部同步
    • 考虑使用 shared_mutex 实现读写锁

map 是 C++ 中最有用的容器之一，理解其内部实现和特性可以帮助你编写出更高效、更安全的代码。根据具体需求选择合适的变体（如 unordered_map 或 multimap），并充分利用现代 C++ 提供的各种优化手段。

数据结构C++——矩阵【详】
qq_60987997的博客
07-22 1400
m x n 矩阵:m行和n列的表M(i,j)：矩阵M 中第i 行、第j 列的元素转置矩阵加矩阵乘使用二维数组描述矩阵：mapiji−1∗nj−1mapiji−1∗nj−1数组的0行和0列不用。
map、set（底层结构）——C++
Ll_R_lL的博客
11-16 3064
高度平衡二叉搜索树，是以人名命名的一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：如果一棵二叉搜索树是的，它就是AVL树。如果它有n个结点，其高度可保持在 O(log2n)O(log_2 n)O(log2​n)，搜索时间复杂度O(log2nlog_2 nlog2​n)平衡因子需要三叉链 但是旋转的时候也会变复杂 t AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步： 原则： 如果在一棵原本是平衡的AVL树中插入一个新节点
C++数据结构——栈
热门推荐
GeekZW的博客
06-25 17万+
C++数据结构——栈 最近计划再复习一遍数据结构，看到一篇博客：https://www.cnblogs.com/QG-whz/p/5170418.html#_label0。 1、栈(Stack)是一种线性存储结构，它具有如下特点： ...
C++数据结构——哈希表
_Y__X_的博客
06-13 1851
文章目录1.unordered_map/unordered_set2. 底层结构2.1哈希概念2.2哈希函数2.3常见哈希函数2.4 哈希冲突3.闭散列（开放定址法）3.1线性探测3.2闭散列扩容-载荷因子3.3二次探测4.开散列4.1开散列增容 1.unordered_map/unordered_set unordered_map是存储<key, value>键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。 在unordered_map中，键值通常用于惟一地标识元素，
【C++】—— map 与 multimap
yusjushd的博客
12-07 2270
容器 map/multimap 的使用介绍
C++数据结构 —— 红黑树
weixin_59913110的博客
03-03 4939
enum Corlor //枚举颜色RED,BLACKtemplate //为了方便，使用K模型K _key;{}
C++ —— map系列的使用
hedhjd的博客
10-23 5853
map可以对两个无关的值建立关系map的声明如下，Key就是map底层关键字的类型，T是map底层value的类型，set默认要求Key⽀持⼩于⽐较，如果不⽀持或者需要的话可以⾃⾏实现仿函数传给第⼆个模版参数map底层存储数据的内存是从空间配置器申请的。⼀般情况下，我们都不需要传后两个模版参数map底层是⽤红⿊树实现，增删查改效率是 O(logN) ，迭代器遍历是⾛的中序，所以是按key有序顺序遍历的map的三种构造//1.显式实例化直接构造//mapint main()//显式定义。
C++——数据结构
摸鱼中......
03-11 6221
前言 线性表（有序表）分为数组描述的线性表和链式描述的线性表。 数组和矩阵。 栈和队列。 跳表和散列。 二叉树和其他树。 优先级队列。 竞赛树和搜索树。 平衡搜索树。 图。 一、线性表——数组描述 （1）数组类型（通过模板类解决）和数组长度（动态数组解决）。 （2）动态数组，可以使用一个变量（非const值）从键盘上获取数组的长度： int n; printf("请输入数组的长度："); scanf("%d",&n); int sz[n];//动态数组 （3）没有实现代码的成员函数称为纯虚函数；
C++STL容器——map和set
未知陨落的博客
11-15 1988
在初阶阶段，我们已经接触过STL中的部分容器，比如：vector、list、deque、 forward_list(C++11)等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。那什么是关联式容器？它与序列式容器有什么区别？ 关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是结构的键值对，在数据检索时比序列式容器效率更高
C/C++数据结构——道路建设（最小生成树Prim）
weixin_44546342的博客
07-27 1671
随着如今社会的不断变化，交通问题也变得越来越重要，所以市长决定建设一些公路来方便各个城市之间的贸易和交易。如果可以的话，输出Yes，否则输出No（两个城市不一定要直接的公路相连，间接公路到达也可以。接下来的n行给出建立公路的成本信息，每行给出三个整数，分别是相连的两个城市v1、v2(0......
《数据结构——C++实现》（第二版）课本源代码.zip
06-16
《数据结构——C++实现》（第二版）是一本深入讲解这一主题的教材，提供了源代码供读者实践和学习。 本书的C++实现部分，旨在帮助读者掌握各种基本和高级数据结构，如数组、链表、栈、队列、树（二叉树、平衡树）、...
数据结构、算法与应用——C++语言描述.rar
07-25
《数据结构、算法与应用——C++语言描述》是一本深入探讨计算机科学核心领域的经典教材。数据结构和算法是编程的基础，它们对于理解和优化程序性能至关重要。本书通过C++语言来阐述这些概念，使得读者能够更好地掌握...
C++数据结构 —— 哈希表、unordered_map/set封装
weixin_59913110的博客
03-17 1736
顺序结构以及平衡二叉搜索树结构中，在查找一个元素时需要经过比较。顺序查找时间复杂度为O(N)，平衡二叉搜索树查找时间复杂度为O(log_2N)。理想的搜索方法便是不经过任何比较，通过常数次的操作从表中得到搜索的元素。如果构造一种存储结构，如果某种函数使元素的存储位置与它存储的元素之间形成一种映射关系，那么在查找中可以通过该函数很快找到搜索元素。该方式称为哈希(散列)方法，哈希方法使用的转换函数称为哈希函数， 构造出来的数据结构称为哈希表。
2025.4.27_C_Struct,Enum,Union
2201_75347713的博客
04-27 948
一系列具有相同类型或不同类型的数据构成的数据集合。
C++笔记-模板进阶和继承(上)
2301_80236968的博客
04-27 922
先讲第一条：关于父类的private成员，不管你是什么继承方式都是子类和类外无法访问的，这就像每个人都有自己的隐私，你的父母也有自己的隐私，隐私当然是不能被其他人看的。第三条的意思是取继承方式和父类成员权限的较小值，这里权限只是一种说法，后面就是权限的大小关系，取其中的较小值后父类的成员或者函数就变成子类中的相应权限的成员和函数。在上面的例子中，父类和子类中都有num1成员变量，但我们通过结果可知，输出的并不是父类中的num1，而是子类中的num1，此时就是子类把父类的同名成员给隐藏了。
深入理解C语言中的整形提升与算术转换
最新发布
qinyuz的博客
05-01 381
在C语言中，整形提升（Integer Promotion）是一个重要但容易被忽视的概念。它指的是在表达式中，任何小于。是无符号char，赋值-1会转换为255（0xFF）长度为标准操作数长度，使用标准长度可以提高运算效率。都是有符号char，值为-1（内存表示：0xFF）：符号扩展为0xFFFFFFFF（即-1）：零扩展为0x000000FF（即255））操作数在使用前都会被自动转换为普通整型。：确保不同大小的整型在运算时有一致的表现。有符号类型：高位补符号位。无符号类型：高位补0。是2字节，所以前两个。
C++入侵检测与网络攻防之DPI项目初始化搭建
qq_27302885的博客
04-28 1030
C++入侵检测与网络攻防之DPI项目初始化搭建
第十六届蓝桥杯 2025 C/C++组 数列差分
2301_80558092的博客
04-30 584
核心算法：排序+双指针。想要操作次数尽可能少所以肯定是一一对应：大的减大的，小的减小的。调整时肯定把bn改的越小越好，这样改完之后b数组排序这个值就会排到最前面
第 11 届蓝桥杯 C++ 青少组中 / 高级组省赛 2020 年真题答和案解析
m0_46324731的博客
04-30 640
'6' 的 ASCII 码为 54，'1' 的 ASCII 码为 49，二者相减结果为 5，是整数类型，因此选 A。：栈（Stack）遵循先进后出（LIFO）原则，队列是先进先出（FIFO），双向链表和二叉树无此特性，选 B。：二维数组按行存储，假设数组索引从 0 开始，第 i 行（0≤i）前有 i 行，每行 n 列，共 i。：每张纸可打印 2 页，当 N 为奇数时，最后一张纸只用一面，故需向上取整，公式为。例如，N=7 时，(7+1)/2=4，符合样例输出。：表达式 ‘6’ - ‘1’ 的值是 ( )
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值