stl源码剖析 详细学习笔记 RB_tree (1)

//

//  RB_tree_STL.cpp

//  笔记

//

//  Created by fam on 15/3/21.

//

//

#include "RB_tree_STL.h"

//---------------------------15/03/21----------------------------

RB_tree

{

   /*

        一个由上而下程序:

        为了避免父子节点皆为红色的情况持续向上层发展，形成处理时效上的瓶颈，可以从上向下处理，

        假设新增的节点为a，那就沿着a的路径，只要看到一个节点的两个子节点都是红色，就把这个节点改为红色

        其他两个子节点改成黑色。

    */

    

    

    //RB_tree的节点设计

    

   typedef bool __rb_tree_color_type;

   const __rb_tree_color_type __rb_tree_red = false; //红色为0

   const __rb_tree_color_type __rb_tree_black = true;

    

    

    //__rb_tree_node_base

   struct __rb_tree_node_base

    {

       typedef __rb_tree_color_type color_type;

       typedef __rb_tree_node_base* base_ptr;

        

        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;

        }

    };

    

    

    //__rb_tree_node

    

    template<class Value>

   struct __rb_tree_node : public __rb_tree_node_base

    {

       typedef __rb_tree_node<Value>* link_type;

        Value value_field;

    };

    //节点设计结束

    

   /*

        re_tree的迭代器

        re_tree的迭代器和slist的迭代器很相似，都是分成两层结构

        re_tree属于双向迭代器，但是不具备随机定位的能力

     

    */

    

    

    //__rb_tree_base_iterator

   struct __rb_tree_base_iterator

    {

       typedef __rb_tree_node_base::base_ptr  base_ptr;

       typedef bidirectional_iterator_tag iterator_category;

       typedef ptrdiff_t difference_type;

        base_ptr node;

        

       void increment()

        {

           if(node->right != 0)

            {

                node = node->right;

               while (node->left != 0)

                    node =node->left;

            }

            //只要node是他父节点的右儿子，他就比他父亲大，我们要找比node大的

           else

            {

                base_ptr y= node->parent;

               while(node == y->right)

                {

                    node = y;

                    y = y->parent;

                }

               if(node->right != y)//如果node是根节点，而且没有右儿子

                    node=y;

            }

        }

        

       void decrement()

        {

            //这个发生在node时header或者end()时

           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;

            }

        }

        

        //原文说increment有4种状况，其实只有三种，状况2并不是一种结果

   

        

    };

    

   template<class Value,class Ref,class Ptr>

   struct __rb_tree_iterator : public __rb_tree_base_iterator

    {

       typedef Value value_type;

       typedef Ref reference;

       typedef Ptr pointer;

       typedef __rb_tree_iterator<Value, Value&, Value*> iterator;

       typedef __rb_tree_iterator<Value,const Value&,const Value*> const_iterator;

       typedef __rb_tree_iterator<Value, Ref, Ptr> self;

        //经过多日的stl熏陶，感觉有些明白self和iterator的关系了，self是当前的节点本身(因为self用到的地方

        //很多，可以简化书写，iterator是一个类型属性供别人使用的。

       typedef __rb_tree_node<Value>* link_type;

        

       //构造函数

        __rb_tree_iterator(){}

        __rb_tree_iterator(link_type x) {node = x;}

        __rb_tree_iterator(const iterator& x) {node = it.node;}

        

        referenceoperator*() const {return link_type(node)->value_field;}

    #ifdef __SGI_STL_NO_ARROW_OPERATOR

        pointeroperator->() const {return &(operator*());}

    #endif

        

        

        //++ --操作

        self&operator++() {increment(); return *this;}

        

        self&operator++(){increment();return *this;}

        selfoperator++(int)

        {

            self tmp = *this;

            increment();

           return tmp;

        }

        self&operator--(){decrement();return *this;}

        selfoperator--(int)

        {

            self tmp = *this;

            decrement();

           return tmp;

        }

    }

    

    

    //class rb_tree

   template<class Key,class Value, class KeyOfValue,class Compare,

           class Alloc = alloc>

   class rb_tree

    {

    protected:

       typedef void* void_point;

       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;

       typedef __rb_tree_color_type color_type;

        

    public:

       typedef Key key_type;

       typedef Value value_type;

       typedef value_type* pointer;

       typedef const value_type* const_pointer;

       typedef value_type& reference;

       typedef const value_type& const_reference;

       typedef rb_tree_node* link_type;

       typedef size_t size_type;

       typedef ptrdiff_t difference_type;

        

    protected:

        //内存分配和释放

        link_type get_node()

        {

           return rb_tree_node_allocator::allocate();

        }

       void put_node(link_type p)

        {

            rb_tree_node_allocator::deallocate(p);

        }

        

        //申请内存并调用构造函数等于new操作

        link_type create_node(const value_type& x)

        {

            link_type tmp = get_node();

            __STL_TRY

            {

                construct(&tmp->value_field,x);

            }

            

            __STL_UNWIND(put_node(tmp));

           return tmp;

        }

        

        //克隆一个节点,只有颜色和键值，不会拷贝关系(左右儿子) 有个疑问，为什么parent没有赋0

        link_type clone_node(link_type x)

        {

            link_type tmp = create_node(x->value_field);

            tmp->color = x->color;

            tmp->left =0;

            tmp->right =0;

           return temp;

        }

        

       void destroy_node(link_type p)

        {

            destroy(&p->value_field);

            put_node(p);

        }

        

        

    protected:

        

        size_type node_count;

        link_type header;

        Compare key_compare;

        

        link_type& root()const {return (link_type&) header->parent;}

        link_type& leftmost()const {return (link_type&) header->left;}

        link_type rightmost()const {return (link_type&) header->right;}

        

        

        //一下12个函数全部为了简化取成员操作

       static link_type& left(link_type x)

        {

           return (link_type&)(x->left);

        }

        

       static link_type& right(link_type x)

        {

           return (link_type&)(x->right);

        }

        

       static link_type& parent(link_type x)

        {

           return (link_type&)(x->parent);

        }

        

       static reference& value(link_type x)

        {

           return x->value_field;

        }

        

       static const Key& key(link_type x)

        {

           return KeyOfValue()( value(x));

        }

        

       static color_type& color(link_type x)

        {

           return (color_type&)(x->color);

        }

        

                    

       static link_type& left(base_ptr x)

        {

           return (link_type&)(x->left);

        }

        

       static link_type& right(base_ptr x)

        {

           return (link_type&)(x->right);

        }

        

       static link_type& parent(base_ptr x)

        {

           return (link_type&)(x->parent);

        }

        

       static reference& value(base_ptr x)

        {

           return ((link_type)x)->value_field;

        }

        

       static const Key& key(base_ptr x)

        {

           return KeyOfValue()( value(link_type(x)));

        }

        

       static color_type& color(base_ptr x)

        {

           return (color_type&)(link_type(x)->color);

        }

        

        //求最大和最小值

       static link_type minimum(link_type x)

        {

           return (link_type) __rb_tree_node_base::minimum(x);

        }

        

       static link_type maximum(link_type x)

        {

           return (link_type) __rb_tree_node_base::maximum(x);

        }

        

        

    public:

       typedef __rb_tree_iterator<value_type, reference, pointer> iterator;

        

    private:

        iterator __insert(base_ptr x, base_ptr y,const value_type& v);

        link_type __copy(link_type x, link_type p);

       void __erase(link_type x);

        //初始化，给header申请一个节点的内存，让root(header->parent)为0，让左右最值都为header,并设置成红色

       void init()

        {

            header = get_node();

            color(header) = __rb_tree_red;

            

            root() =0;

            leftmost() = header;

            rightmost() =header;

        }

        

        

    public:

        rb_tree(const Compare& comp=Compare()

                : node_count(0), key_compare(comp))

        {

                    init();

        }

        

        ~rb_tree()

        {

            clear();

            put_node(header);

        }

        

        rb_tree<Key, Value, KeyOfValue, Compare, Alloc>&

       operator=(const rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& x);

        

    public:

       //各种基础操作

        Compare key_comp()const {return key_compare;}

        iterator begin() {return leftmost();}

        iterator end() {return header;}

       bool empty() const {return node_count ==0;}

        size_type size()const {return node_count;}

        size_type max_size()const {return size_type(-1);}

        

    public:

        

        pair<iterator,bool> insert_unique(const value_type& x);

        

        

        

    };