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 != 0) x = x->left;
        return x;
    }

    static base_ptr maximum(base_ptr x)
    {
        while (x->right != 0) 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 != 0) {
        node = node->right;
        while (node->left != 0)
            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 != 0) {
        base_ptr y = node->left;
        while (y->right != 0)
            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)的時間復雜度(沒有沖突情況下)，但是它們的元素的順序是無序的。