set集合容器

最新推荐文章于 2021-09-03 00:00:39 发布
最新推荐文章于 2021-09-03 00:00:39 发布
阅读量260 收藏
点赞数
分类专栏： c++STL 文章标签： set集合容器 红黑树 应用 案例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hopegrace/article/details/104136672
版权

set集合容器

一、原理

set集合容器使用一种称为红黑树（Red-Black Tree）的平衡二叉检索树的数据结构，来组织泛化的元素数据。每个节点包含一个取值红色或黑色的颜色域，以利于进行树的平衡处理。作为节点键值的元素的插入，必须确保每个子树根节点的键值大于左子树所有节点的键值，而小于右子树所有节点的键值。不会将重复的键值插入容器，也不需指定具体的插入位置，而按元素在树中的关联关系，进行位置检索和插入，元素的删除亦然。 

元素数据的检索，使用的是二叉检索树的中序遍历算法，检索的效率高于vector、deque和 list 等容器。由于采用中序遍历算法可将二叉检索树的键值，由小到大排列遍历出来，因此set集合容器蕴含了元素间的有序性。

1、红黑树的定义

    如下是红黑树在二叉检索树基础上所作的补充定义，可以看到C++ STL的红黑树对标准红黑树略作修改，不要求叶子节点必须是黑色。 

（1）根节点是黑色。 

（2）其他节点是红色或黑色。 

（3）每个红色节点的左、右节点必须是黑色。 

（4）每条从叶子节点到根节点的路径，都包含相同数目的黑色节点。

可见，红黑树使用红黑二色进行“着色”，目的是利用颜色值做二叉树的平衡对称性的检查，只要插入的节点“着色”满足红黑二色的规定，最短路径与最长路径不会相差太远，红黑树的节点分布就能大体上达至平衡。当然，这种平衡是一种有所放宽的平衡。 

由性质（3）可得出，红黑树的任何路径都不会出现两个相邻的红色节点，否则存在一对父子节点都是红色。 

由性质（4），可设从根节点到叶节点路径上的黑色节点数均为n，于是，红黑树的最短路径为全黑的“黑→黑→…→黑”路径，即最短路径长度为n?1（相邻节点间的距离为1）。而最长路径只能取为红黑交替的“黑→红→黑→红→…→黑”路径，这样可使黑色节点数最多，即最长路径为2(n?1)。所以在红黑树的所有从根节点到叶子节点的路径中，最长路径不会超过最短路径的2倍。

2、结构

将一组整数21、30、10、8、37、46、29、5、16、19、15和32依次插入生成一个红黑树。如图所示，先构造一个黑色节点21作为根，由于30＞21，因此30作为21的右节点插入，10＜21，10作为21的左节点插入。

    元素检索的时间复杂度是log2n(n为元素个数)。

3、说明

红黑树的插入和删除都要涉及类似平衡二叉树如何进行平衡问题。关于平衡二叉树，我们可以参见：

http://blog.163.com/zhoumhan_0351/blog/static/399542272009104113331705

关于红黑树调整代码，可以参见SGI的stl_tree文件中。附中有一部分关键的。

二、应用

1、创建

（1）set()用默认的less函数对象和内存分配器，创建一个没有任何数据元素的set对象。

set<int> s;//创建了空的set对象s ，元素类型为整型int。

（2）set(const key_compare& comp) 

指定一个比较函数对象comp来创建set对象，内存分配器为默认值。

//定义字符串比较函数对象strLess 

struct strLess{ 

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

{ return strcmp(s1, s2) < 0;}

};

//创建set容器对象s 

set<const char*, strLess> s(strLess());//使用自定义的函数对象strLess，创建一个set容器对象s

（3）set(const set&) 

set拷贝构造函数，通过红黑树的拷贝构造函数，实现两个set容器的元素、头节点和节点个数的拷贝。

//set<int> s1; 

set<int> s2(s1);//利用set容器对象s1，拷贝生成set容器对象s2。 

（4）set(InputIterator first, InputIterator last)

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

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

set<int> s(iArray, iArray +3);//将数组iArray的元素插入到set容器对象s的红黑树中。 

（5）set(InputIterator first, InputIterator last, const key_compare& comp) 

用迭代器区间[first,  last)所指的元素和 comp 函数对象，创建一个 set 对象。

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

set<const char*, strLess> s(szArray, szArray +3 , strLess());//用上面定义的strLess函数对象和数组szArray，创建set对象s

2、插入

（1）pair<iterator, bool> insert(const value_type& v) 

将元素v插入set容器，要求v值不与set容器的任何元素重复，否则插入失败。返回一个pair配对对象，提供所插入元素的迭代器位置和true/false插入成功标志。 

（2）iterator insert(iterator position, const value_type& v) 

将元素v插入set容器，参数position只是提示可在position位置之前插入v，所返回的插入位置视实际情况而定，不一定能在position位置前插入。 

（3）void insert(InputIterator first, InputIterator last) 

将某迭代器区间［first,last)所指的数据作为元素，插入到set容器。

3、访问

（1）iterator begin()//通过迭代器的“++”进行中序遍历

（2）iterator end() 

及反向迭找器

4、寻找

const_iterator find(const Key& key) const;

5、其它

其它函数，如删除erase,empty,size,swap,等，基本用法同其它的容器，可参考相关的C++文档，如MSDN。

三、例子

#include "set.h"

#include "iostream"

using namespace std;

int main()

{

set<int> s;

s.insert(10);

s.insert(11);

s.insert(12);

s.insert(13);

set<int>::iterator i;

for(i=s.begin();i!=s.end();i++)

 cout<<(*i)<<" ";

return 1;

}

附：SGI中红黑树的调整代码

 _Rb_tree_rotate_left(_Rb_tree_node_base* x, _Rb_tree_node_base*& root)

  {

    _Rb_tree_node_base* y = x->_M_right;

    x->_M_right = y->_M_left;

    if (y->_M_left !=0)

      y->_M_left->_M_parent = x;

    y->_M_parent = x->_M_parent;

    

    if (x == root)

      root = y;

    else if (x == x->_M_parent->_M_left)

      x->_M_parent->_M_left = y;

    else

      x->_M_parent->_M_right = y;

    y->_M_left = x;

    x->_M_parent = y;

  }

  inline void 

  _Rb_tree_rotate_right(_Rb_tree_node_base* x, _Rb_tree_node_base*& root)

  {

    _Rb_tree_node_base* y = x->_M_left;

    x->_M_left = y->_M_right;

    if (y->_M_right != 0)

      y->_M_right->_M_parent = x;

    y->_M_parent = x->_M_parent;

    if (x == root)

      root = y;

    else if (x == x->_M_parent->_M_right)

      x->_M_parent->_M_right = y;

    else

      x->_M_parent->_M_left = y;

    y->_M_right = x;

    x->_M_parent = y;

  }

  inline void 

  _Rb_tree_rebalance(_Rb_tree_node_base* x, _Rb_tree_node_base*& root)

  {

    x->_M_color = _M_red;

    while (x != root 

    && x->_M_parent->_M_color == _M_red) 

      {

 if (x->_M_parent == x->_M_parent->_M_parent->_M_left) 

   {

     _Rb_tree_node_base* y = x->_M_parent->_M_parent->_M_right;

     if (y && y->_M_color == _M_red) 

       {

  x->_M_parent->_M_color = _M_black;

  y->_M_color = _M_black;

  x->_M_parent->_M_parent->_M_color = _M_red;

  x = x->_M_parent->_M_parent;

       }

     else 

       {

  if (x == x->_M_parent->_M_right) 

    {

      x = x->_M_parent;

      _Rb_tree_rotate_left(x, root);

    }

  x->_M_parent->_M_color = _M_black;

  x->_M_parent->_M_parent->_M_color = _M_red;

  _Rb_tree_rotate_right(x->_M_parent->_M_parent, root);

       }

   }

 else 

   {

     _Rb_tree_node_base* y = x->_M_parent->_M_parent->_M_left;

     if (y && y->_M_color == _M_red) 

       {

  x->_M_parent->_M_color = _M_black;

  y->_M_color = _M_black;

  x->_M_parent->_M_parent->_M_color = _M_red;

  x = x->_M_parent->_M_parent;

       }

     else 

       {

  if (x == x->_M_parent->_M_left) 

    {

      x = x->_M_parent;

      _Rb_tree_rotate_right(x, root);

    }

  x->_M_parent->_M_color = _M_black;

  x->_M_parent->_M_parent->_M_color = _M_red;

  _Rb_tree_rotate_left(x->_M_parent->_M_parent, root);

       }

   }

      }

    root->_M_color = _M_black;

  }

inline _Rb_tree_node_base*

  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* z, 

          _Rb_tree_node_base*& root,

          _Rb_tree_node_base*& leftmost,

          _Rb_tree_node_base*& rightmost)

  {

    _Rb_tree_node_base* y = z;

    _Rb_tree_node_base* x = 0;

    _Rb_tree_node_base* x_parent = 0;

    if (y->_M_left == 0)     // z has at most one non-null child. y == z.

      x = y->_M_right;     // x might be null.

    else

      if (y->_M_right == 0)  // z has exactly one non-null child. y == z.

 x = y->_M_left;    // x is not null.

      else 

 {

   // z has two non-null children.  Set y to

   y = y->_M_right;   //   z's successor.  x might be null.

   while (y->_M_left != 0)

     y = y->_M_left;

   x = y->_M_right;

 }

    if (y != z) 

      {

 // relink y in place of z.  y is z's successor

 z->_M_left->_M_parent = y; 

 y->_M_left = z->_M_left;

 if (y != z->_M_right) 

   {

     x_parent = y->_M_parent;

     if (x) x->_M_parent = y->_M_parent;

     y->_M_parent->_M_left = x;   // y must be a child of _M_left

     y->_M_right = z->_M_right;

     z->_M_right->_M_parent = y;

   }

 else

   x_parent = y;  

 if (root == z)

   root = y;

 else if (z->_M_parent->_M_left == z)

   z->_M_parent->_M_left = y;

 else 

   z->_M_parent->_M_right = y;

 y->_M_parent = z->_M_parent;

 std::swap(y->_M_color, z->_M_color);

 y = z;

 // y now points to node to be actually deleted

      }

    else 

      {                        // y == z

 x_parent = y->_M_parent;

 if (x) 

   x->_M_parent = y->_M_parent;   

 if (root == z)

   root = x;

 else 

   if (z->_M_parent->_M_left == z)

     z->_M_parent->_M_left = x;

   else

     z->_M_parent->_M_right = x;

 if (leftmost == z) 

   if (z->_M_right == 0)        // z->_M_left must be null also

     leftmost = z->_M_parent;

 // makes leftmost == _M_header if z == root

   else

     leftmost = _Rb_tree_node_base::_S_minimum(x);

 if (rightmost == z)  

   if (z->_M_left == 0)         // z->_M_right must be null also

     rightmost = z->_M_parent;  

 // makes rightmost == _M_header if z == root

   else                      // x == z->_M_left

     rightmost = _Rb_tree_node_base::_S_maximum(x);

      }

    if (y->_M_color != _M_red) 

      { 

 while (x != root && (x == 0 || x->_M_color == _M_black))

   if (x == x_parent->_M_left) 

     {

       _Rb_tree_node_base* w = x_parent->_M_right;

       if (w->_M_color == _M_red) 

  {

    w->_M_color = _M_black;

    x_parent->_M_color = _M_red;

    _Rb_tree_rotate_left(x_parent, root);

    w = x_parent->_M_right;

  }

       if ((w->_M_left == 0 || 

     w->_M_left->_M_color == _M_black) &&

    (w->_M_right == 0 || 

     w->_M_right->_M_color == _M_black)) 

  {

    w->_M_color = _M_red;

    x = x_parent;

    x_parent = x_parent->_M_parent;

  } 

       else 

  {

    if (w->_M_right == 0 

        || w->_M_right->_M_color == _M_black) 

      {

        w->_M_left->_M_color = _M_black;

        w->_M_color = _M_red;

        _Rb_tree_rotate_right(w, root);

        w = x_parent->_M_right;

      }

    w->_M_color = x_parent->_M_color;

    x_parent->_M_color = _M_black;

    if (w->_M_right) 

      w->_M_right->_M_color = _M_black;

    _Rb_tree_rotate_left(x_parent, root);

    break;

  }

     } 

   else 

     {   

       // same as above, with _M_right <-> _M_left.

       _Rb_tree_node_base* w = x_parent->_M_left;

       if (w->_M_color == _M_red) 

  {

    w->_M_color = _M_black;

    x_parent->_M_color = _M_red;

    _Rb_tree_rotate_right(x_parent, root);

    w = x_parent->_M_left;

  }

       if ((w->_M_right == 0 || 

     w->_M_right->_M_color == _M_black) &&

    (w->_M_left == 0 || 

     w->_M_left->_M_color == _M_black)) 

  {

    w->_M_color = _M_red;

    x = x_parent;

    x_parent = x_parent->_M_parent;

  } 

       else 

  {

    if (w->_M_left == 0 || w->_M_left->_M_color == _M_black) 

      {

        w->_M_right->_M_color = _M_black;

        w->_M_color = _M_red;

        _Rb_tree_rotate_left(w, root);

        w = x_parent->_M_left;

      }

    w->_M_color = x_parent->_M_color;

    x_parent->_M_color = _M_black;

    if (w->_M_left) 

      w->_M_left->_M_color = _M_black;

    _Rb_tree_rotate_right(x_parent, root);

    break;

  }

     }

 if (x) x->_M_color = _M_black;

      }

    return y;

  }

参考：

1、C++ STL开发导引

2、SGI文件,MSDN

hopegrace
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Stl中map、set 容器（数据结构：AVL树、红黑树）--C++
qq_63412763的博客
09-24 1393
Stl的容器中，map和set都是用的树状数据结构----二叉树！但实际上用的并不是普普通通的树状结构，而是一种设计好的，规律性极强的树状数据结构：红黑树（二叉树的一种，细节下面讲）对于map和set来讲，中序遍历依旧是有序的，而这和之前讲的二叉搜索树有点相似。
【MFC】容器类的使用
xd1103121507的专栏
02-21 7532
对于MFC中所提到的基本容器类，做一个基本的介绍和编程操作。 　　如有数据结构基础，可以直接看第四部分对容器类的操作。 　　第一，MFC提供三种基本的容器类：arrays(数组), lists(链表), maps(映射,也称作字典). 　　第二，各容器类的特征分类 类型 排序? 索引? 插入元素 查找特定元素 重复的元素? List Yes No
C++ STL Set容器(深入了解,一文学会)
断点
09-03 3331
和 map、multimap 容器不同，使用 set 容器存储的各个键值对，要求键 key 和值 value 必须相等。 通过前面的学习我们知道，map、multimap 容器都会自行根据键的大小对存储的键值对进行排序，set 容器也会如此，只不过 set 容器中各键值对的键 key 和值 value 是相等的，根据 key 排序，也就等价为根据 value 排序。 另外，使用 set 容器存储的各个元素的值必须各不相同。更重要的是，从语法上讲 set 容器...
STL详解（七） 集合容器set
流年的博客
02-01 1168
一、set简介 C++ STL 之所以得到广泛的赞誉，也被很多人使用，不只是提供了像vector, string, list等方便的容器，更重要的是STL封装了许多复杂的数据结构算法和大量常用数据结构操作。vector封装数组，list封装了链表，map和set封装了二叉树，pair封装二元结构体等，在封装这些数据结构的时候，STL按照程序员的使用习惯，以成员函数方式提供的常用操作，如：插入、排...
C++ Set（集合）
01-06
set 是一个内部自动有序且不含重复元素的容器。 set 最主要的作用就是自动去重并按升序排序，适用于需要去重但是又不方便直接开数组的情况。 set 中的元素是唯一的，其内部采用“红黑树”实现。 注：本文章只列举 ...
c++ STL库容器之集合set代码实例
12-20
set是STL中一种标准关联容器，其键值就是实值，实值就是键值，不可以有重复，所以我们不能通过set的迭代器来改变set的元素的值。它底层使用平衡的搜索树——红黑树实现，插入删除操作时仅仅需要指针操作节点即可完成...
Java集合容器集合框架Set集(与“集合”有关文档共23张).pptx
11-14
Java集合容器集合框架Set集(与“集合”有关文档共23张).pptx
Java 容器类源码详解 Set
08-25
主要介绍了Java 容器类源码详解 Set，Set 表示由无重复对象组成的集合，也是集合框架中重要的一种集合类型，直接扩展自 Collection 接口。,需要的朋友可以参考下
set容器使用方法
I_O_fly的博客
03-08 3677
/*set/multiset特性 set/multiset的特性是所有元素会根据元素的值自动进行排序，set是以RB-tree （红黑树 平衡二叉树的一种）为底层机制，其查找效率非常好 set容器中不允许重复元素,multiset允许重复元素set构造函数set&lt;T&gt; st;//set 默认构造函数mulitset&lt;T&gt; mst;//mulitset默认构造函数set(co...
C++_MFC_容器、标准库、模板.
05-17
我们应该注意到，没有一个受过伦理教育的软件工程师会同意开发出“摧毁巴格达”的程序。然而基本的职业道德却可以要求他们开发出“摧毁城市”的程序，巴格达只是这个程序的一个参数。
MFC中STL容器中Vector,List,Map基本用法汇总
leiyang2014的博客
01-07 9913
容器就是数据结构的泛指，迭代器就是指针的泛指，可以指向元素。它可以用来存储数据，就比如杯子用来装水一样。而STL中的容器有很多，它包括vector，list，map，deque，set等。我就简单列举vector，list，map为例吧， 1.Vector 又称向量，跟数组结构差不多。它的内存是连续的，拥有与数组一样的特点，但它又更加灵活，可以在首尾两端插入删除数据更加方便。支持[]操作符，在
c++中的set容器元素（圣诞快乐）
To-nemy
12-25 704
关与set的认识，由于最近写了一道题，问了好多人，大部分都说用set或hash ，，（哈哈…….）.这东西在我脑子里一片空白。搜索了部分博友的博客。顺便尝试了一下，感觉挺好用的，总结一下他们的博文。 set有几个常见的问题：为何map和set的插入删除效率比用其他序列容器高？ 大部分人说很贱，因为对于关联容器来说，不许做内存拷贝和内存移动。确实如此。set容器内所有元素都是一节点的方式来存储的，器节
【STL】set容器
此地无银
10-29 1106
位于 std 命名空间中
C++ 中的set 容器
weixin_34384557的博客
08-23 342
1set容器set容器简介：set是一个容器，它用于储存数据并且能从一个数据集合中取出数据。它的每个元素的值必须惟一，而且系统会根据该值来自动将数据排序。每个元素的值不能直接被改变。关键字：begin、clear、count、empty、end、find、insert需加载的头文件：#include<set>模板原型：template < clas...
stl之set集合容器应用基础
Hao_09的专栏
07-03 3489
set集合容器使用一种称为红黑树(Red-Black Tree) 的平衡二叉检索树的数据结构，来组织泛化的元素数据。每个节点包含一个取值红色或黑色的颜色域，以利于进行树的平衡处理。作为节点键值的元素的插入，必须确保每个子树根节点的键值大于左子树所有节点的键值，而小于右子树所有节点的键值。不会将重复的键值插入容器，也不需要指定具体的插入位置，而按元素在树中的关联关系，进行位置检索和插入，元素的删除亦
C++ STL set集合容器常用用法
踏雪无痕
07-04 7896
set集合容器：实现了红黑树的平衡二叉检索树的数据结构，插入元素时，它会自动调整二叉树的排列，把元素放到适当的位置，以保证每个子树根节点键值大于左子树所有节点的键值，小于右子树所有节点的键值；另外，还得保证根节点左子树的高度与右子树高度相等。 平衡二叉检索树使用中序遍历算法，检索效率高于vector、deque和list等容器，另外使用中序遍历可将键值按照从小到大遍历出来。 构造set集合主要
C++ STL 容器篇之集合set
亓官劼的博客
10-28 4402
C++ STL 容器篇之集合set set是我们经常使用的一个容器，他是一个集合。不仅如此，它还把一些常用的操作封装在了set类型内，它在头文件中。 声明 set是一个模板类，每次使用时需要定义类型，例如set a这样来声明一个set。set一个int类型的数据集合。 set的特性 set的特性是，所有元素都会根据元素的键值自动排序，set的元素不像map那样可以同时拥有实值(value)和键值...
迭代器遍历set集合
最新发布
05-25
在C++中，使用迭代器遍历set集合非常简单。set是一个关联容器，其中的元素按照特定的顺序排列，因此可以使用set的迭代器来实现遍历。 以下是一个简单的示例代码，展示如何使用迭代器遍历set集合： ```c++ #include...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值