STL源码剖析(set/map)

SGI STL中set/map底层都是通过RB-tree实现的。

首先看看RB-tree结点的定义

 typedef bool __rb_tree_color_type;
 const __rb_tree_color_type __rb_tree_red = false;
 const __rb_tree_color_type __rb_tree_black = true;

 // 结点的基类
 struct __rb_tree_node_base
 {
     typedef __rb_tree_color_type color_type;
     typedef __rb_tree_node_base* base_ptr;

     // 关键的4个域
     color_type color;
     base_ptr parent;
     base_ptr left;
     base_ptr right;

     // 返回极值
     static base_ptr minimum(base_ptr x)
    {
         while (x->left != ) x = x->left;
         return x;
     }

     static base_ptr maximum(base_ptr x)
     {
         while (x->right != ) x = x->right;
         return x;
      }
 }

 // 多了一个value域
 template <class Value>
 struct __rb_tree_node : public __rb_tree_node_base
 {
     typedef __rb_tree_node<Value>* link_type;
     Value value_field;
 };

下图是RB-tree结点跟其迭代器的关系

重点看看__rb_tree_iterator的operator++跟operator--，

实际是调用__rb_tree_base_iterator的increment跟decrement。

可以看出迭代器前移/后移的时候会按key的顺序找到下一个/上一个结点。

(set/map<...>::begin()会返回RB-tree中key最小的结点，因此使用operator++遍历会按key的顺序从小到大遍历结点)

 void increment()
 {
     if (node->right != ) {
         node = node->right;
         while (node->left != )
             node = node->left;
     }
     else {
         base_ptr y = node->parent;
         while (node == y->right) {
             node = y;
             y = y->parent;
         }
         if (node->right != y)
             node = y;
     }
 }

 void decrement()
 {
     if (node->color == __rb_tree_red &&
         node->parent->parent == node)
         node = node->right;
     else if (node->left != ) {
         base_ptr y = node->left;
         while (y->right != )
             y = y->right;
         node = y;
     }
     else {
         base_ptr y = node->parent;
         while (node == y->left) {
             node = y;
             y = y->parent;
         }
         node = y;
     }
 }

SGI STL中的rb_tree用了一个小trick，就是使用了一个header结点，用来代表整个rb_tree。

该结点与root结点互为父结点，该结点的left指向最左(key最小)的结点，right指向最右(key最大)的结点。

除此之外，该rb_tree的实现跟普通的红黑树类似，详情可以查看:http://www.cnblogs.com/runnyu/p/4679279.html。

 template <class Key, class Value, class KeyOfValue, class Compare,
           class Alloc = alloc>
 class rb_tree {
     // rb_tree的基本定义
 protected:
     typedef __rb_tree_node_base* base_ptr;
     typedef __rb_tree_node<Value> rb_tree_node;
     typedef simple_alloc<rb_tree_node, Alloc> rb_tree_node_allocator;
 public:
     typedef Key key_type;
     typedef Value value_type;
     typedef value_type* pointer;
     typedef value_type& reference;
     typedef rb_tree_node* link_type;
     typedef size_t size_type;
     typedef ptrdiff_t difference_type;

     typedef __rb_tree_iterator<value_type, reference, pointer> iterator;

     link_type header;
     // ...

     // 主要接口
     iterator begin() { return leftmost(); } // 返回最左边的结点(最小key)
     iterator end() { return header; }

     iterator insert_equal(const value_type& x); // 插入元素 并允许键值相同
     pair<iterator,bool> insert_unique(const value_type& x); // 插入元素 键值是独一无二的

 };

set/multiset

有了rb_tree，set/multiset的实现也只是调用rb_tree的接口而已。

其中set跟multiset不一样的是，set插入的时候调用的是insert_unique()，而multiset调用的是insert_equal()。

下面是给出set的基本定义：

 template <class Key, class Compare = less<Key>, class Alloc = alloc>
 class set {
 public:
     typedef Key key_type;
     typedef Key value_type;  // 使用的value类型跟key一样
     typedef Compare key_compare;
     typedef Compare value_compare;
 private:
     typedef rb_tree<key_type, value_type,
                   identity<value_type>, key_compare, Alloc> rep_type;
     rep_type t;
 public:
     // 接口的实现只是对rb_tree的封装  不一一列举了
     iterator begin() const { return t.begin(); }
     iterator end() const { return t.end(); }
     pair<iterator,bool> insert(const value_type& x) {
         pair<typename rep_type::iterator, bool> p = t.insert_unique(x);
         return pair<iterator, bool>(p.first, p.second);
     }
     // ...
 };

map/multimap

map/mulitmap的实现也是通过调用rb_tree的接口。

map/mulitmap不一样的是，map插入的时候调用的是insert_unique()，而multimap调用的是insert_equal()。

下面是给出map的基本定义：

 template <class Key, class T, class Compare = less<Key>, class Alloc
 class map {
 public:
     typedef Key key_type;
     typedef T data_type;
     typedef T mapped_type;
     typedef pair<const Key, T> value_type; // 在rb_tree中value的类型是pair
     typedef Compare key_compare;
 private:
     // select1st直接return T.first 用于rb_tree取到key进行比较大小
     typedef rb_tree<key_type, value_type,
                   select1st<value_type>, key_compare, Alloc> rep_type;
     rep_type t;
     // ...

     // 接口只是对rb_tree的封装  就不一一列举了
     iterator begin() { return t.begin(); }
     iterator end() { return t.end(); }
     pair<iterator,bool> insert(const value_type& x) { return t.insert_unique(x); }
      // ...
 }

另外STL中有未列入标准的hash_set/hash_map以及C++11中的unordered_set/map，底层是使用hashtable实现的。

相比于用rb_tree实现的set/map，它们的插入删除查找操作具有O(1)的时间复杂度(没有冲突情况下)，但是它们的元素的顺序是无序的。