C++ map,set内部数据结构

「爱情、让人受尽委屈。」 2022-08-13 14:42 150阅读 0赞

1）Set是一种关联容器，它用于存储数据，并且能从一个数据集合中取出数据。它的每个元素的值必须唯一，而且系统会根据该值来自动将数据排序。每个元素的值不能直接被改变。【重点】内部结构采用红黑树的平衡二叉树。multiset 跟set 类似，唯一的区别是允许键值重复！！！

如： 为何map和set的插入删除效率比用其他序列容器高？

为何每次insert之后，以前保存的iterator不会失效？

为何map和set不能像vector一样有个reserve函数来预分配数据？

当数据元素增多时（10000到20000个比较），map和set的插入和搜索速度变化如何？

或许有得人能回答出来大概原因，但要彻底明白，还需要了解STL的底层数据结构。 C++ STL 之所以得到广泛的赞誉，也被很多人使用，不只是提供了像vector, string, list等方便的容器，更重要的是STL封装了许多复杂的数据结构算法和大量常用数据结构操作。vector封装数组，list封装了链表，map和 set封装了二叉树等，在封装这些数据结构的时候，STL按照程序员的使用习惯，以成员函数方式提供的常用操作，如：插入、排序、删除、查找等。让用户在 STL使用过程中，并不会感到陌生。 C++ STL中标准关联容器set, multiset, map, multimap内部采用的就是一种非常高效的平衡检索二叉树：红黑树，也成为RB树(Red-Black Tree)。RB树的统计性能要好于一般的平衡二叉树(有些书籍根据作者姓名，Adelson-Velskii和Landis，将其称为AVL-树)，所以被STL选择作为了关联容器的内部结构。本文并不会介绍详细AVL树和RB树的实现以及他们的优劣，关于RB树的详细实现参看红黑树: 理论与实现(理论篇)。本文针对开始提出的几个问题的回答，来向大家简单介绍map和set的底层数据结构。

为何map和set的插入删除效率比用其他序列容器高？ 大部分人说，很简单，因为对于关联容器来说，不需要做内存拷贝和内存移动。说对了，确实如此。map和set容器内所有元素都是以节点的方式来存储，其节点结构和链表差不多，指向父节点和子节点。

结构图可能如下：

/  /

B    C

/ /   / /

D  E F  G

因此插入的时候只需要稍做变换，把节点的指针指向新的节点就可以了。删除的时候类似，稍做变换后把指向删除节点的指针指向其他节点就OK了。这里的一切操作就是指针换来换去，和内存移动没有关系。 为何每次insert之后，以前保存的iterator不会失效？ 看见了上面答案的解释，你应该已经可以很容易解释这个问题。iterator这里就相当于指向节点的指针，内存没有变，指向内存的指针怎么会失效呢(当然 被删除的那个元素本身已经失效了)。相对于vector来说，每一次删除和插入，指针都有可能失效，调用push\_back在尾部插入也是如此。因为为了 保证内部数据的连续存放，iterator指向的那块内存在删除和插入过程中可能已经被其他内存覆盖或者内存已经被释放了。即使时push\_back的时 候，容器内部空间可能不够，需要一块新的更大的内存，只有把以前的内存释放，申请新的更大的内存，复制已有的数据元素到新的内存，最后把需要插入的元素放 到最后，那么以前的内存指针自然就不可用了。特别时在和find等算法在一起使用的时候，牢记这个原则：不要使用过期的iterator。 为何map和set不能像vector一样有个reserve函数来预分配数据？ 我以前也这么问，究其原理来说时，引起它的原因在于在map和set内部存储的已经不是元素本身了，而是包含元素的节点。也就是说map内部使用的Alloc并不是map声明的时候从参数中传入的Alloc。例如： map, Alloc > intmap; 这时候在intmap中使用的allocator并不是Alloc, 而是通过了转换的Alloc，具体转换的方法时在内部通过Alloc::rebind重新定义了新的节点分配器，详细的实现参看彻底学习STL中的Allocator。其实你就记住一点，在map和set内面的分配器已经发生了变化，reserve方法你就不要奢望了。 当数据元素增多时（10000和20000个比较），map和set的插入和搜索速度变化如何？ 如果你知道log2的关系你应该就彻底了解这个答案。在map和set中查找是使用二分查找，也就是说，如果有16个元素，最多需要比较4次就能找到结 果，有32个元素，最多比较5次。那么有10000个呢？最多比较的次数为log10000，最多为14次，如果是20000个元素呢？最多不过15次。 看见了吧，当数据量增大一倍的时候，搜索次数只不过多了1次，多了1/14的搜索时间而已。你明白这个道理后，就可以安心往里面放入元素了。 最后，对于map和set Winter还要提的就是它们和一个c语言包装库的效率比较。在许多unix和linux平台下，都有一个库叫isc，里面就提供类似于以下声明的函数: void tree\_init(void \*\*tree); void \*tree\_srch(void \*\*tree, int (\*compare)(), void \*data); void tree\_add(void \*\*tree, int (\*compare)(), void \*data, void (\*del\_uar)()); int tree\_delete(void \*\*tree, int (\*compare)(), void \*data,void (\*del\_uar)()); int tree\_trav(void \*\*tree, int (\*trav\_uar)()); void tree\_mung(void \*\*tree, void (\*del\_uar)()); 许多人认为直接使用这些函数会比STL map速度快，因为STL map中使用了许多模板什么的。其实不然，它们的区别并不在于算法，而在于内存碎片。如果直接使用这些函数，你需要自己去new一些节点，当节点特别多， 而且进行频繁的删除和插入的时候，内存碎片就会存在，而STL采用自己的Allocator分配内存，以内存池的方式来管理这些内存，会大大减少内存碎 片，从而会提升系统的整体性能。Winter在自己的系统中做过测试，把以前所有直接用isc函数的代码替换成map，程序速度基本一致。当时间运行很长 时间后（例如后台服务程序），map的优势就会体现出来。从另外一个方面讲，使用map会大大降低你的编码难度，同时增加程序的可读性。何乐而不为？

`/*`

`set/multiset会根据待定的排序准则，自动将元素排序。两者不同在于前者不允许元素重复，而后者允许。`

`1) 不能直接改变元素值，因为那样会打乱原本正确的顺序，要改变元素值必须先删除旧元素，则插入新元素`

`2) 不提供直接存取元素的任何操作函数，只能通过迭代器进行间接存取，而且从迭代器角度来看，元素值是常数`

`3) 元素比较动作只能用于型别相同的容器(即元素和排序准则必须相同)`

`set模板原型：//Key为元素(键值)类型`

`template <class Key, class Compare=less<Key>, class Alloc=STL_DEFAULT_ALLOCATOR(Key) >`

`从原型可以看出，可以看出比较函数对象及内存分配器采用的是默认参数，因此如果未指定，它们将采用系统默认方式，`

`另外，利用原型，可以有效地辅助分析创建对象的几种方式`

`*/`

`#include <iostream>`

`#include <string>`

`#include <set>`

`using`  `namespace`  `std;`

`struct`  `strLess`

`{`

`   ` `bool`  `operator() (` `const`  `char`  `*s1,` `const`  `char`  `*s2)` `const`

`   ` `{`

`    ` `return`  `strcmp` `(s1, s2) < 0;`

`   ` `}`

`};`

`void`  `printSet(set<` `int` `> s)`

`{`

`copy(s.begin(), s.end(), ostream_iterator<` `int` `>(cout,` `", "` `) );`

`// set<int>::iterator iter;`

`// for (iter = s.begin(); iter != s.end(); iter++)`

`//    //cout<<"set["<<iter-s.begin()<<"]="<<*iter<<", "; //Error`

`//    cout<<*iter<<", ";`

`cout<<endl;`

`}`

`void`  `main()`

`{`

`//创建set对象，共5种方式，提示如果比较函数对象及内存分配器未出现，即表示采用的是系统默认方式`

`//创建空的set对象，元素类型为int，`

`set<` `int` `> s1;`

`//创建空的set对象，元素类型char*，比较函数对象(即排序准则)为自定义strLess`

`set<` `const`  `char` `*, strLess> s2( strLess);`

`//利用set对象s1,拷贝生成set对象s2`

`set<` `int` `> s3(s1);`

`//用迭代区间[&first, &last)所指的元素，创建一个set对象`

`int`  `iArray[] = {13, 32, 19};`

`set<` `int` `> s4(iArray, iArray + 3);`

`//用迭代区间[&first, &last)所指的元素，及比较函数对象strLess，创建一个set对象`

`const`  `char` `* szArray[] = {` `"hello"` `,` `"dog"` `,` `"bird"`  `};`

`set<` `const`  `char` `*, strLess> s5(szArray, szArray + 3, strLess() );`

`//元素插入：`

`//1,插入value，返回pair配对对象，可以根据.second判断是否插入成功。(提示:value不能与set容器内元素重复)`

`//pair<iterator, bool> insert(value)`

`//2,在pos位置之前插入value，返回新元素位置，但不一定能插入成功`

`//iterator insert(&pos, value)`

`//3,将迭代区间[&first, &last)内所有的元素，插入到set容器`

`//void insert[&first, &last)`

`cout<<` `"s1.insert() : "` `<<endl;`

`for`  `(` `int`  `i = 0; i <5 ; i++)`

`    ` `s1.insert(i*10);`

`printSet(s1);`

`cout<<` `"s1.insert(20).second = "` `<<endl;;`

`if`  `(s1.insert(20).second)`

`    ` `cout<<` `"Insert OK!"` `<<endl;`

`else`

`    ` `cout<<` `"Insert Failed!"` `<<endl;`

`cout<<` `"s1.insert(50).second = "` `<<endl;`

`if`  `(s1.insert(50).second)`

`{cout<<` `"Insert OK!"` `<<endl; printSet(s1);}`

`else`

`    ` `cout<<` `"Insert Failed!"` `<<endl;`

`cout<<` `"pair<set<int>::iterator::iterator, bool> p;\np = s1.insert(60);\nif (p.second):"` `<<endl;`

`pair<set<` `int` `>::iterator::iterator,` `bool` `> p;`

`p = s1.insert(60);`

`if`  `(p.second)`

`{cout<<` `"Insert OK!"` `<<endl; printSet(s1);}`

`else`

`   ` `cout<<` `"Insert Failed!"` `<<endl;`

`//元素删除`

`//1,size_type erase(value) 移除set容器内元素值为value的所有元素，返回移除的元素个数`

`//2,void erase(&pos) 移除pos位置上的元素，无返回值`

`//3,void erase(&first, &last) 移除迭代区间[&first, &last)内的元素，无返回值`

`//4,void clear()， 移除set容器内所有元素`

`cout<<` `"\ns1.erase(70) = "` `<<endl;`

`s1.erase(70);`

`printSet(s1);`

`cout<<` `"s1.erase(60) = "` `<<endl;`

`s1.erase(60);`

`printSet(s1);`

`cout<<` `"set<int>::iterator iter = s1.begin();\ns1.erase(iter) = "` `<<endl;`

`set<` `int` `>::iterator iter = s1.begin();`

`s1.erase(iter);`

`printSet(s1);`

`//元素查找`

`//count(value)返回set对象内元素值为value的元素个数`

`//iterator find(value)返回value所在位置，找不到value将返回end()`

`//lower_bound(value),upper_bound(value), equal_range(value) 略`

`cout<<` `"\ns1.count(10) = "` `<<s1.count(10)<<` `", s1.count(80) = "` `<<s1.count(80)<<endl;`

`cout<<` `"s1.find(10) : "` `;`

`if`  `(s1.find(10) != s1.end())`

`    ` `cout<<` `"OK!"` `<<endl;`

`else`

`    ` `cout<<` `"not found!"` `<<endl;`

`cout<<` `"s1.find(80) : "` `;`

`if`  `(s1.find(80) != s1.end())`

`    ` `cout<<` `"OK!"` `<<endl;`

`else`

`    ` `cout<<` `"not found!"` `<<endl;`

`//其它常用函数`

`cout<<` `"\ns1.empty()="` `<<s1.empty()<<` `", s1.size()="` `<<s1.size()<<endl;`

`set<` `int` `> s9;`

`s9.insert(100);`

`cout<<` `"s1.swap(s9) :"` `<<endl;`

`s1.swap(s9);`

`cout<<` `"s1: "` `<<endl;`

`printSet(s1);`

`cout<<` `"s9: "` `<<endl;`

`printSet(s9);`

`//lower_bound,upper_bound,equal_range(略)`

`}`

`///i测试结果/`

`s1.insert() :`

`0, 10, 20, 30, 40,`

`s1.insert(20).second =`

`Insert Failed!`

`s1.insert(50).second =`

`Insert OK!`

`0, 10, 20, 30, 40, 50,`

`pair<set<` `int` `>::iterator::iterator,` `bool` `> p;`

`p = s1.insert(60);`

`if`  `(p.second):`

`Insert OK!`

`0, 10, 20, 30, 40, 50, 60,`

`s1.erase(70) =`

`0, 10, 20, 30, 40, 50, 60,`

`s1.erase(60) =`

`0, 10, 20, 30, 40, 50,`

`set<` `int` `>::iterator iter = s1.begin();`

`s1.erase(iter) =`

`10, 20, 30, 40, 50,`

`s1.count(10) = 1, s1.count(80) = 0`

`s1.find(10) : OK!`

`s1.find(80) : not found!`

`s1.empty()=0, s1.size()=5`

`s1.swap(s9) :`

`s1:`

`100,`

`s9:`

`10, 20, 30, 40, 50,`

C++ map,set内部数据结构

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关通过代码快速上手C语言数据结构-内部排序

相关数据结构python版答案_「Python」 - 内部数据结构

相关 redis：数据结构和内部编码

相关 C++ map,set内部数据结构

相关 C++ map,set内部数据结构

相关数据结构之内部排序三

相关数据结构之内部排序二

相关图解数据结构---“内部排序”综述

相关 Redis数据结构的内部编码

相关 C++类的内部结构