stl_tree.h
上传用户:sichengcw
上传日期:2009-02-17
资源大小:202k
文件大小:35k
源码类别:

STL

开发平台:

Visual C++

  1. /*
  2.  *
  3.  * Copyright (c) 1996,1997
  4.  * Silicon Graphics Computer Systems, Inc.
  5.  *
  6.  * Permission to use, copy, modify, distribute and sell this software
  7.  * and its documentation for any purpose is hereby granted without fee,
  8.  * provided that the above copyright notice appear in all copies and
  9.  * that both that copyright notice and this permission notice appear
  10.  * in supporting documentation.  Silicon Graphics makes no
  11.  * representations about the suitability of this software for any
  12.  * purpose.  It is provided "as is" without express or implied warranty.
  13.  *
  14.  *
  15.  * Copyright (c) 1994
  16.  * Hewlett-Packard Company
  17.  *
  18.  * Permission to use, copy, modify, distribute and sell this software
  19.  * and its documentation for any purpose is hereby granted without fee,
  20.  * provided that the above copyright notice appear in all copies and
  21.  * that both that copyright notice and this permission notice appear
  22.  * in supporting documentation.  Hewlett-Packard Company makes no
  23.  * representations about the suitability of this software for any
  24.  * purpose.  It is provided "as is" without express or implied warranty.
  25.  *
  26.  *
  27.  */
  28. /* NOTE: This is an internal header file, included by other STL headers.
  29.  *   You should not attempt to use it directly.
  30.  */
  31. #ifndef __SGI_STL_INTERNAL_TREE_H
  32. #define __SGI_STL_INTERNAL_TREE_H
  33. /*
  34. Red-black tree class, designed for use in implementing STL
  35. associative containers (set, multiset, map, and multimap). The
  36. insertion and deletion algorithms are based on those in Cormen,
  37. Leiserson, and Rivest, Introduction to Algorithms (MIT Press, 1990),
  38. except that
  39. (1) the header cell is maintained with links not only to the root
  40. but also to the leftmost node of the tree, to enable constant time
  41. begin(), and to the rightmost node of the tree, to enable linear time
  42. performance when used with the generic set algorithms (set_union,
  43. etc.);
  44. (2) when a node being deleted has two children its successor node is
  45. relinked into its place, rather than copied, so that the only
  46. iterators invalidated are those referring to the deleted node.
  47. */
  48. #include <stl_algobase.h>
  49. #include <stl_alloc.h>
  50. #include <stl_construct.h>
  51. #include <stl_function.h>
  52. __STL_BEGIN_NAMESPACE 
  53. typedef bool __rb_tree_color_type;
  54. const __rb_tree_color_type __rb_tree_red = false;
  55. const __rb_tree_color_type __rb_tree_black = true;
  56. struct __rb_tree_node_base
  57. {
  58.   typedef __rb_tree_color_type color_type;
  59.   typedef __rb_tree_node_base* base_ptr;
  60.   color_type color; 
  61.   base_ptr parent;
  62.   base_ptr left;
  63.   base_ptr right;
  64.   static base_ptr minimum(base_ptr x)
  65.   {
  66.     while (x->left != 0) x = x->left;
  67.     return x;
  68.   }
  69.   static base_ptr maximum(base_ptr x)
  70.   {
  71.     while (x->right != 0) x = x->right;
  72.     return x;
  73.   }
  74. };
  75. template <class Value>
  76. struct __rb_tree_node : public __rb_tree_node_base
  77. {
  78.   typedef __rb_tree_node<Value>* link_type;
  79.   Value value_field;
  80. };
  81. struct __rb_tree_base_iterator
  82. {
  83.   typedef __rb_tree_node_base::base_ptr base_ptr;
  84.   typedef bidirectional_iterator_tag iterator_category;
  85.   typedef ptrdiff_t difference_type;
  86.   base_ptr node;
  87.   void increment()
  88.   {
  89.     if (node->right != 0) {
  90.       node = node->right;
  91.       while (node->left != 0)
  92.         node = node->left;
  93.     }
  94.     else {
  95.       base_ptr y = node->parent;
  96.       while (node == y->right) {
  97.         node = y;
  98.         y = y->parent;
  99.       }
  100.       if (node->right != y)
  101.         node = y;
  102.     }
  103.   }
  104.   void decrement()
  105.   {
  106.     if (node->color == __rb_tree_red &&
  107.         node->parent->parent == node)
  108.       node = node->right;
  109.     else if (node->left != 0) {
  110.       base_ptr y = node->left;
  111.       while (y->right != 0)
  112.         y = y->right;
  113.       node = y;
  114.     }
  115.     else {
  116.       base_ptr y = node->parent;
  117.       while (node == y->left) {
  118.         node = y;
  119.         y = y->parent;
  120.       }
  121.       node = y;
  122.     }
  123.   }
  124. };
  125. template <class Value, class Ref, class Ptr>
  126. struct __rb_tree_iterator : public __rb_tree_base_iterator
  127. {
  128.   typedef Value value_type;
  129.   typedef Ref reference;
  130.   typedef Ptr pointer;
  131.   typedef __rb_tree_iterator<Value, Value&, Value*>             iterator;
  132.   typedef __rb_tree_iterator<Value, const Value&, const Value*> const_iterator;
  133.   typedef __rb_tree_iterator<Value, Ref, Ptr>                   self;
  134.   typedef __rb_tree_node<Value>* link_type;
  135.   __rb_tree_iterator() {}
  136.   __rb_tree_iterator(link_type x) { node = x; }
  137.   __rb_tree_iterator(const iterator& it) { node = it.node; }
  138.   reference operator*() const { return link_type(node)->value_field; }
  139. #ifndef __SGI_STL_NO_ARROW_OPERATOR
  140.   pointer operator->() const { return &(operator*()); }
  141. #endif /* __SGI_STL_NO_ARROW_OPERATOR */
  142.   self& operator++() { increment(); return *this; }
  143.   self operator++(int) {
  144.     self tmp = *this;
  145.     increment();
  146.     return tmp;
  147.   }
  148.     
  149.   self& operator--() { decrement(); return *this; }
  150.   self operator--(int) {
  151.     self tmp = *this;
  152.     decrement();
  153.     return tmp;
  154.   }
  155. };
  156. inline bool operator==(const __rb_tree_base_iterator& x,
  157.                        const __rb_tree_base_iterator& y) {
  158.   return x.node == y.node;
  159. }
  160. inline bool operator!=(const __rb_tree_base_iterator& x,
  161.                        const __rb_tree_base_iterator& y) {
  162.   return x.node != y.node;
  163. }
  164. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  165. inline bidirectional_iterator_tag
  166. iterator_category(const __rb_tree_base_iterator&) {
  167.   return bidirectional_iterator_tag();
  168. }
  169. inline __rb_tree_base_iterator::difference_type*
  170. distance_type(const __rb_tree_base_iterator&) {
  171.   return (__rb_tree_base_iterator::difference_type*) 0;
  172. }
  173. template <class Value, class Ref, class Ptr>
  174. inline Value* value_type(const __rb_tree_iterator<Value, Ref, Ptr>&) {
  175.   return (Value*) 0;
  176. }
  177. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  178. inline void 
  179. __rb_tree_rotate_left(__rb_tree_node_base* x, __rb_tree_node_base*& root)
  180. {
  181.   __rb_tree_node_base* y = x->right;
  182.   x->right = y->left;
  183.   if (y->left !=0)
  184.     y->left->parent = x;
  185.   y->parent = x->parent;
  186.   if (x == root)
  187.     root = y;
  188.   else if (x == x->parent->left)
  189.     x->parent->left = y;
  190.   else
  191.     x->parent->right = y;
  192.   y->left = x;
  193.   x->parent = y;
  194. }
  195. inline void 
  196. __rb_tree_rotate_right(__rb_tree_node_base* x, __rb_tree_node_base*& root)
  197. {
  198.   __rb_tree_node_base* y = x->left;
  199.   x->left = y->right;
  200.   if (y->right != 0)
  201.     y->right->parent = x;
  202.   y->parent = x->parent;
  203.   if (x == root)
  204.     root = y;
  205.   else if (x == x->parent->right)
  206.     x->parent->right = y;
  207.   else
  208.     x->parent->left = y;
  209.   y->right = x;
  210.   x->parent = y;
  211. }
  212. inline void 
  213. __rb_tree_rebalance(__rb_tree_node_base* x, __rb_tree_node_base*& root)
  214. {
  215.   x->color = __rb_tree_red;
  216.   while (x != root && x->parent->color == __rb_tree_red) {
  217.     if (x->parent == x->parent->parent->left) {
  218.       __rb_tree_node_base* y = x->parent->parent->right;
  219.       if (y && y->color == __rb_tree_red) {
  220.         x->parent->color = __rb_tree_black;
  221.         y->color = __rb_tree_black;
  222.         x->parent->parent->color = __rb_tree_red;
  223.         x = x->parent->parent;
  224.       }
  225.       else {
  226.         if (x == x->parent->right) {
  227.           x = x->parent;
  228.           __rb_tree_rotate_left(x, root);
  229.         }
  230.         x->parent->color = __rb_tree_black;
  231.         x->parent->parent->color = __rb_tree_red;
  232.         __rb_tree_rotate_right(x->parent->parent, root);
  233.       }
  234.     }
  235.     else {
  236.       __rb_tree_node_base* y = x->parent->parent->left;
  237.       if (y && y->color == __rb_tree_red) {
  238.         x->parent->color = __rb_tree_black;
  239.         y->color = __rb_tree_black;
  240.         x->parent->parent->color = __rb_tree_red;
  241.         x = x->parent->parent;
  242.       }
  243.       else {
  244.         if (x == x->parent->left) {
  245.           x = x->parent;
  246.           __rb_tree_rotate_right(x, root);
  247.         }
  248.         x->parent->color = __rb_tree_black;
  249.         x->parent->parent->color = __rb_tree_red;
  250.         __rb_tree_rotate_left(x->parent->parent, root);
  251.       }
  252.     }
  253.   }
  254.   root->color = __rb_tree_black;
  255. }
  256. inline __rb_tree_node_base*
  257. __rb_tree_rebalance_for_erase(__rb_tree_node_base* z,
  258.                               __rb_tree_node_base*& root,
  259.                               __rb_tree_node_base*& leftmost,
  260.                               __rb_tree_node_base*& rightmost)
  261. {
  262.   __rb_tree_node_base* y = z;
  263.   __rb_tree_node_base* x = 0;
  264.   __rb_tree_node_base* x_parent = 0;
  265.   if (y->left == 0)             // z has at most one non-null child. y == z.
  266.     x = y->right;               // x might be null.
  267.   else
  268.     if (y->right == 0)          // z has exactly one non-null child.  y == z.
  269.       x = y->left;              // x is not null.
  270.     else {                      // z has two non-null children.  Set y to
  271.       y = y->right;             //   z's successor.  x might be null.
  272.       while (y->left != 0)
  273.         y = y->left;
  274.       x = y->right;
  275.     }
  276.   if (y != z) {                 // relink y in place of z.  y is z's successor
  277.     z->left->parent = y; 
  278.     y->left = z->left;
  279.     if (y != z->right) {
  280.       x_parent = y->parent;
  281.       if (x) x->parent = y->parent;
  282.       y->parent->left = x;      // y must be a left child
  283.       y->right = z->right;
  284.       z->right->parent = y;
  285.     }
  286.     else
  287.       x_parent = y;  
  288.     if (root == z)
  289.       root = y;
  290.     else if (z->parent->left == z)
  291.       z->parent->left = y;
  292.     else 
  293.       z->parent->right = y;
  294.     y->parent = z->parent;
  295.     __STD::swap(y->color, z->color);
  296.     y = z;
  297.     // y now points to node to be actually deleted
  298.   }
  299.   else {                        // y == z
  300.     x_parent = y->parent;
  301.     if (x) x->parent = y->parent;   
  302.     if (root == z)
  303.       root = x;
  304.     else 
  305.       if (z->parent->left == z)
  306.         z->parent->left = x;
  307.       else
  308.         z->parent->right = x;
  309.     if (leftmost == z) 
  310.       if (z->right == 0)        // z->left must be null also
  311.         leftmost = z->parent;
  312.     // makes leftmost == header if z == root
  313.       else
  314.         leftmost = __rb_tree_node_base::minimum(x);
  315.     if (rightmost == z)  
  316.       if (z->left == 0)         // z->right must be null also
  317.         rightmost = z->parent;  
  318.     // makes rightmost == header if z == root
  319.       else                      // x == z->left
  320.         rightmost = __rb_tree_node_base::maximum(x);
  321.   }
  322.   if (y->color != __rb_tree_red) { 
  323.     while (x != root && (x == 0 || x->color == __rb_tree_black))
  324.       if (x == x_parent->left) {
  325.         __rb_tree_node_base* w = x_parent->right;
  326.         if (w->color == __rb_tree_red) {
  327.           w->color = __rb_tree_black;
  328.           x_parent->color = __rb_tree_red;
  329.           __rb_tree_rotate_left(x_parent, root);
  330.           w = x_parent->right;
  331.         }
  332.         if ((w->left == 0 || w->left->color == __rb_tree_black) &&
  333.             (w->right == 0 || w->right->color == __rb_tree_black)) {
  334.           w->color = __rb_tree_red;
  335.           x = x_parent;
  336.           x_parent = x_parent->parent;
  337.         } else {
  338.           if (w->right == 0 || w->right->color == __rb_tree_black) {
  339.             if (w->left) w->left->color = __rb_tree_black;
  340.             w->color = __rb_tree_red;
  341.             __rb_tree_rotate_right(w, root);
  342.             w = x_parent->right;
  343.           }
  344.           w->color = x_parent->color;
  345.           x_parent->color = __rb_tree_black;
  346.           if (w->right) w->right->color = __rb_tree_black;
  347.           __rb_tree_rotate_left(x_parent, root);
  348.           break;
  349.         }
  350.       } else {                  // same as above, with right <-> left.
  351.         __rb_tree_node_base* w = x_parent->left;
  352.         if (w->color == __rb_tree_red) {
  353.           w->color = __rb_tree_black;
  354.           x_parent->color = __rb_tree_red;
  355.           __rb_tree_rotate_right(x_parent, root);
  356.           w = x_parent->left;
  357.         }
  358.         if ((w->right == 0 || w->right->color == __rb_tree_black) &&
  359.             (w->left == 0 || w->left->color == __rb_tree_black)) {
  360.           w->color = __rb_tree_red;
  361.           x = x_parent;
  362.           x_parent = x_parent->parent;
  363.         } else {
  364.           if (w->left == 0 || w->left->color == __rb_tree_black) {
  365.             if (w->right) w->right->color = __rb_tree_black;
  366.             w->color = __rb_tree_red;
  367.             __rb_tree_rotate_left(w, root);
  368.             w = x_parent->left;
  369.           }
  370.           w->color = x_parent->color;
  371.           x_parent->color = __rb_tree_black;
  372.           if (w->left) w->left->color = __rb_tree_black;
  373.           __rb_tree_rotate_right(x_parent, root);
  374.           break;
  375.         }
  376.       }
  377.     if (x) x->color = __rb_tree_black;
  378.   }
  379.   return y;
  380. }
  381. template <class Key, class Value, class KeyOfValue, class Compare,
  382.           class Alloc = alloc>
  383. class rb_tree {
  384. protected:
  385.   typedef void* void_pointer;
  386.   typedef __rb_tree_node_base* base_ptr;
  387.   typedef __rb_tree_node<Value> rb_tree_node;
  388.   typedef simple_alloc<rb_tree_node, Alloc> rb_tree_node_allocator;
  389.   typedef __rb_tree_color_type color_type;
  390. public:
  391.   typedef Key key_type;
  392.   typedef Value value_type;
  393.   typedef value_type* pointer;
  394.   typedef const value_type* const_pointer;
  395.   typedef value_type& reference;
  396.   typedef const value_type& const_reference;
  397.   typedef rb_tree_node* link_type;
  398.   typedef size_t size_type;
  399.   typedef ptrdiff_t difference_type;
  400. protected:
  401.   link_type get_node() { return rb_tree_node_allocator::allocate(); }
  402.   void put_node(link_type p) { rb_tree_node_allocator::deallocate(p); }
  403.   link_type create_node(const value_type& x) {
  404.     link_type tmp = get_node();
  405.     __STL_TRY {
  406.       construct(&tmp->value_field, x);
  407.     }
  408.     __STL_UNWIND(put_node(tmp));
  409.     return tmp;
  410.   }
  411.   link_type clone_node(link_type x) {
  412.     link_type tmp = create_node(x->value_field);
  413.     tmp->color = x->color;
  414.     tmp->left = 0;
  415.     tmp->right = 0;
  416.     return tmp;
  417.   }
  418.   void destroy_node(link_type p) {
  419.     destroy(&p->value_field);
  420.     put_node(p);
  421.   }
  422. protected:
  423.   size_type node_count; // keeps track of size of tree
  424.   link_type header;  
  425.   Compare key_compare;
  426.   link_type& root() const { return (link_type&) header->parent; }
  427.   link_type& leftmost() const { return (link_type&) header->left; }
  428.   link_type& rightmost() const { return (link_type&) header->right; }
  429.   static link_type& left(link_type x) { return (link_type&)(x->left); }
  430.   static link_type& right(link_type x) { return (link_type&)(x->right); }
  431.   static link_type& parent(link_type x) { return (link_type&)(x->parent); }
  432.   static reference value(link_type x) { return x->value_field; }
  433.   static const Key& key(link_type x) { return KeyOfValue()(value(x)); }
  434.   static color_type& color(link_type x) { return (color_type&)(x->color); }
  435.   static link_type& left(base_ptr x) { return (link_type&)(x->left); }
  436.   static link_type& right(base_ptr x) { return (link_type&)(x->right); }
  437.   static link_type& parent(base_ptr x) { return (link_type&)(x->parent); }
  438.   static reference value(base_ptr x) { return ((link_type)x)->value_field; }
  439.   static const Key& key(base_ptr x) { return KeyOfValue()(value(link_type(x)));} 
  440.   static color_type& color(base_ptr x) { return (color_type&)(link_type(x)->color); }
  441.   static link_type minimum(link_type x) { 
  442.     return (link_type)  __rb_tree_node_base::minimum(x);
  443.   }
  444.   static link_type maximum(link_type x) {
  445.     return (link_type) __rb_tree_node_base::maximum(x);
  446.   }
  447. public:
  448.   typedef __rb_tree_iterator<value_type, reference, pointer> iterator;
  449.   typedef __rb_tree_iterator<value_type, const_reference, const_pointer> 
  450.           const_iterator;
  451. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  452.   typedef reverse_iterator<const_iterator> const_reverse_iterator;
  453.   typedef reverse_iterator<iterator> reverse_iterator;
  454. #else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  455.   typedef reverse_bidirectional_iterator<iterator, value_type, reference,
  456.                                          difference_type>
  457.           reverse_iterator; 
  458.   typedef reverse_bidirectional_iterator<const_iterator, value_type,
  459.                                          const_reference, difference_type>
  460.           const_reverse_iterator;
  461. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ 
  462. private:
  463.   iterator __insert(base_ptr x, base_ptr y, const value_type& v);
  464.   link_type __copy(link_type x, link_type p);
  465.   void __erase(link_type x);
  466.   void init() {
  467.     header = get_node();
  468.     color(header) = __rb_tree_red; // used to distinguish header from 
  469.                                    // root, in iterator.operator++
  470.     root() = 0;
  471.     leftmost() = header;
  472.     rightmost() = header;
  473.   }
  474. public:
  475.                                 // allocation/deallocation
  476.   rb_tree(const Compare& comp = Compare())
  477.     : node_count(0), key_compare(comp) { init(); }
  478.   rb_tree(const rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& x) 
  479.     : node_count(0), key_compare(x.key_compare)
  480.   { 
  481.     header = get_node();
  482.     color(header) = __rb_tree_red;
  483.     if (x.root() == 0) {
  484.       root() = 0;
  485.       leftmost() = header;
  486.       rightmost() = header;
  487.     }
  488.     else {
  489.       __STL_TRY {
  490.         root() = __copy(x.root(), header);
  491.       }
  492.       __STL_UNWIND(put_node(header));
  493.       leftmost() = minimum(root());
  494.       rightmost() = maximum(root());
  495.     }
  496.     node_count = x.node_count;
  497.   }
  498.   ~rb_tree() {
  499.     clear();
  500.     put_node(header);
  501.   }
  502.   rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& 
  503.   operator=(const rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& x);
  504. public:    
  505.                                 // accessors:
  506.   Compare key_comp() const { return key_compare; }
  507.   iterator begin() { return leftmost(); }
  508.   const_iterator begin() const { return leftmost(); }
  509.   iterator end() { return header; }
  510.   const_iterator end() const { return header; }
  511.   reverse_iterator rbegin() { return reverse_iterator(end()); }
  512.   const_reverse_iterator rbegin() const { 
  513.     return const_reverse_iterator(end()); 
  514.   }
  515.   reverse_iterator rend() { return reverse_iterator(begin()); }
  516.   const_reverse_iterator rend() const { 
  517.     return const_reverse_iterator(begin());
  518.   } 
  519.   bool empty() const { return node_count == 0; }
  520.   size_type size() const { return node_count; }
  521.   size_type max_size() const { return size_type(-1); }
  522.   void swap(rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& t) {
  523.     __STD::swap(header, t.header);
  524.     __STD::swap(node_count, t.node_count);
  525.     __STD::swap(key_compare, t.key_compare);
  526.   }
  527.     
  528. public:
  529.                                 // insert/erase
  530.   pair<iterator,bool> insert_unique(const value_type& x);
  531.   iterator insert_equal(const value_type& x);
  532.   iterator insert_unique(iterator position, const value_type& x);
  533.   iterator insert_equal(iterator position, const value_type& x);
  534. #ifdef __STL_MEMBER_TEMPLATES  
  535.   template <class InputIterator>
  536.   void insert_unique(InputIterator first, InputIterator last);
  537.   template <class InputIterator>
  538.   void insert_equal(InputIterator first, InputIterator last);
  539. #else /* __STL_MEMBER_TEMPLATES */
  540.   void insert_unique(const_iterator first, const_iterator last);
  541.   void insert_unique(const value_type* first, const value_type* last);
  542.   void insert_equal(const_iterator first, const_iterator last);
  543.   void insert_equal(const value_type* first, const value_type* last);
  544. #endif /* __STL_MEMBER_TEMPLATES */
  545.   void erase(iterator position);
  546.   size_type erase(const key_type& x);
  547.   void erase(iterator first, iterator last);
  548.   void erase(const key_type* first, const key_type* last);
  549.   void clear() {
  550.     if (node_count != 0) {
  551.       __erase(root());
  552.       leftmost() = header;
  553.       root() = 0;
  554.       rightmost() = header;
  555.       node_count = 0;
  556.     }
  557.   }      
  558. public:
  559.                                 // set operations:
  560.   iterator find(const key_type& x);
  561.   const_iterator find(const key_type& x) const;
  562.   size_type count(const key_type& x) const;
  563.   iterator lower_bound(const key_type& x);
  564.   const_iterator lower_bound(const key_type& x) const;
  565.   iterator upper_bound(const key_type& x);
  566.   const_iterator upper_bound(const key_type& x) const;
  567.   pair<iterator,iterator> equal_range(const key_type& x);
  568.   pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
  569. public:
  570.                                 // Debugging.
  571.   bool __rb_verify() const;
  572. };
  573. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  574. inline bool operator==(const rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& x, 
  575.                        const rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& y) {
  576.   return x.size() == y.size() && equal(x.begin(), x.end(), y.begin());
  577. }
  578. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  579. inline bool operator<(const rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& x, 
  580.                       const rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& y) {
  581.   return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
  582. }
  583. #ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
  584. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  585. inline void swap(rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& x, 
  586.                  rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& y) {
  587.   x.swap(y);
  588. }
  589. #endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
  590. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  591. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& 
  592. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::
  593. operator=(const rb_tree<Key, Value, KeyOfValue, Compare, Alloc>& x) {
  594.   if (this != &x) {
  595.                                 // Note that Key may be a constant type.
  596.     clear();
  597.     node_count = 0;
  598.     key_compare = x.key_compare;        
  599.     if (x.root() == 0) {
  600.       root() = 0;
  601.       leftmost() = header;
  602.       rightmost() = header;
  603.     }
  604.     else {
  605.       root() = __copy(x.root(), header);
  606.       leftmost() = minimum(root());
  607.       rightmost() = maximum(root());
  608.       node_count = x.node_count;
  609.     }
  610.   }
  611.   return *this;
  612. }
  613. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  614. typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::iterator
  615. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::
  616. __insert(base_ptr x_, base_ptr y_, const Value& v) {
  617.   link_type x = (link_type) x_;
  618.   link_type y = (link_type) y_;
  619.   link_type z;
  620.   if (y == header || x != 0 || key_compare(KeyOfValue()(v), key(y))) {
  621.     z = create_node(v);
  622.     left(y) = z;                // also makes leftmost() = z when y == header
  623.     if (y == header) {
  624.       root() = z;
  625.       rightmost() = z;
  626.     }
  627.     else if (y == leftmost())
  628.       leftmost() = z;           // maintain leftmost() pointing to min node
  629.   }
  630.   else {
  631.     z = create_node(v);
  632.     right(y) = z;
  633.     if (y == rightmost())
  634.       rightmost() = z;          // maintain rightmost() pointing to max node
  635.   }
  636.   parent(z) = y;
  637.   left(z) = 0;
  638.   right(z) = 0;
  639.   __rb_tree_rebalance(z, header->parent);
  640.   ++node_count;
  641.   return iterator(z);
  642. }
  643. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  644. typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::iterator
  645. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::insert_equal(const Value& v)
  646. {
  647.   link_type y = header;
  648.   link_type x = root();
  649.   while (x != 0) {
  650.     y = x;
  651.     x = key_compare(KeyOfValue()(v), key(x)) ? left(x) : right(x);
  652.   }
  653.   return __insert(x, y, v);
  654. }
  655. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  656. pair<typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::iterator, bool>
  657. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::insert_unique(const Value& v)
  658. {
  659.   link_type y = header;
  660.   link_type x = root();
  661.   bool comp = true;
  662.   while (x != 0) {
  663.     y = x;
  664.     comp = key_compare(KeyOfValue()(v), key(x));
  665.     x = comp ? left(x) : right(x);
  666.   }
  667.   iterator j = iterator(y);   
  668.   if (comp)
  669.     if (j == begin())     
  670.       return pair<iterator,bool>(__insert(x, y, v), true);
  671.     else
  672.       --j;
  673.   if (key_compare(key(j.node), KeyOfValue()(v)))
  674.     return pair<iterator,bool>(__insert(x, y, v), true);
  675.   return pair<iterator,bool>(j, false);
  676. }
  677. template <class Key, class Val, class KeyOfValue, class Compare, class Alloc>
  678. typename rb_tree<Key, Val, KeyOfValue, Compare, Alloc>::iterator 
  679. rb_tree<Key, Val, KeyOfValue, Compare, Alloc>::insert_unique(iterator position,
  680.                                                              const Val& v) {
  681.   if (position.node == header->left) // begin()
  682.     if (size() > 0 && key_compare(KeyOfValue()(v), key(position.node)))
  683.       return __insert(position.node, position.node, v);
  684.   // first argument just needs to be non-null 
  685.     else
  686.       return insert_unique(v).first;
  687.   else if (position.node == header) // end()
  688.     if (key_compare(key(rightmost()), KeyOfValue()(v)))
  689.       return __insert(0, rightmost(), v);
  690.     else
  691.       return insert_unique(v).first;
  692.   else {
  693.     iterator before = position;
  694.     --before;
  695.     if (key_compare(key(before.node), KeyOfValue()(v))
  696.         && key_compare(KeyOfValue()(v), key(position.node)))
  697.       if (right(before.node) == 0)
  698.         return __insert(0, before.node, v); 
  699.       else
  700.         return __insert(position.node, position.node, v);
  701.     // first argument just needs to be non-null 
  702.     else
  703.       return insert_unique(v).first;
  704.   }
  705. }
  706. template <class Key, class Val, class KeyOfValue, class Compare, class Alloc>
  707. typename rb_tree<Key, Val, KeyOfValue, Compare, Alloc>::iterator 
  708. rb_tree<Key, Val, KeyOfValue, Compare, Alloc>::insert_equal(iterator position,
  709.                                                             const Val& v) {
  710.   if (position.node == header->left) // begin()
  711.     if (size() > 0 && key_compare(KeyOfValue()(v), key(position.node)))
  712.       return __insert(position.node, position.node, v);
  713.   // first argument just needs to be non-null 
  714.     else
  715.       return insert_equal(v);
  716.   else if (position.node == header) // end()
  717.     if (!key_compare(KeyOfValue()(v), key(rightmost())))
  718.       return __insert(0, rightmost(), v);
  719.     else
  720.       return insert_equal(v);
  721.   else {
  722.     iterator before = position;
  723.     --before;
  724.     if (!key_compare(KeyOfValue()(v), key(before.node))
  725.         && !key_compare(key(position.node), KeyOfValue()(v)))
  726.       if (right(before.node) == 0)
  727.         return __insert(0, before.node, v); 
  728.       else
  729.         return __insert(position.node, position.node, v);
  730.     // first argument just needs to be non-null 
  731.     else
  732.       return insert_equal(v);
  733.   }
  734. }
  735. #ifdef __STL_MEMBER_TEMPLATES  
  736. template <class K, class V, class KoV, class Cmp, class Al> template<class II>
  737. void rb_tree<K, V, KoV, Cmp, Al>::insert_equal(II first, II last) {
  738.   for ( ; first != last; ++first)
  739.     insert_equal(*first);
  740. }
  741. template <class K, class V, class KoV, class Cmp, class Al> template<class II>
  742. void rb_tree<K, V, KoV, Cmp, Al>::insert_unique(II first, II last) {
  743.   for ( ; first != last; ++first)
  744.     insert_unique(*first);
  745. }
  746. #else /* __STL_MEMBER_TEMPLATES */
  747. template <class K, class V, class KoV, class Cmp, class Al>
  748. void
  749. rb_tree<K, V, KoV, Cmp, Al>::insert_equal(const V* first, const V* last) {
  750.   for ( ; first != last; ++first)
  751.     insert_equal(*first);
  752. }
  753. template <class K, class V, class KoV, class Cmp, class Al>
  754. void
  755. rb_tree<K, V, KoV, Cmp, Al>::insert_equal(const_iterator first,
  756.                                           const_iterator last) {
  757.   for ( ; first != last; ++first)
  758.     insert_equal(*first);
  759. }
  760. template <class K, class V, class KoV, class Cmp, class A>
  761. void 
  762. rb_tree<K, V, KoV, Cmp, A>::insert_unique(const V* first, const V* last) {
  763.   for ( ; first != last; ++first)
  764.     insert_unique(*first);
  765. }
  766. template <class K, class V, class KoV, class Cmp, class A>
  767. void 
  768. rb_tree<K, V, KoV, Cmp, A>::insert_unique(const_iterator first,
  769.                                           const_iterator last) {
  770.   for ( ; first != last; ++first)
  771.     insert_unique(*first);
  772. }
  773. #endif /* __STL_MEMBER_TEMPLATES */
  774.          
  775. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  776. inline void
  777. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::erase(iterator position) {
  778.   link_type y = (link_type) __rb_tree_rebalance_for_erase(position.node,
  779.                                                           header->parent,
  780.                                                           header->left,
  781.                                                           header->right);
  782.   destroy_node(y);
  783.   --node_count;
  784. }
  785. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  786. typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::size_type 
  787. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::erase(const Key& x) {
  788.   pair<iterator,iterator> p = equal_range(x);
  789.   size_type n = 0;
  790.   distance(p.first, p.second, n);
  791.   erase(p.first, p.second);
  792.   return n;
  793. }
  794. template <class K, class V, class KeyOfValue, class Compare, class Alloc>
  795. typename rb_tree<K, V, KeyOfValue, Compare, Alloc>::link_type 
  796. rb_tree<K, V, KeyOfValue, Compare, Alloc>::__copy(link_type x, link_type p) {
  797.                                 // structural copy.  x and p must be non-null.
  798.   link_type top = clone_node(x);
  799.   top->parent = p;
  800.  
  801.   __STL_TRY {
  802.     if (x->right)
  803.       top->right = __copy(right(x), top);
  804.     p = top;
  805.     x = left(x);
  806.     while (x != 0) {
  807.       link_type y = clone_node(x);
  808.       p->left = y;
  809.       y->parent = p;
  810.       if (x->right)
  811.         y->right = __copy(right(x), y);
  812.       p = y;
  813.       x = left(x);
  814.     }
  815.   }
  816.   __STL_UNWIND(__erase(top));
  817.   return top;
  818. }
  819. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  820. void rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::__erase(link_type x) {
  821.                                 // erase without rebalancing
  822.   while (x != 0) {
  823.     __erase(right(x));
  824.     link_type y = left(x);
  825.     destroy_node(x);
  826.     x = y;
  827.   }
  828. }
  829. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  830. void rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::erase(iterator first, 
  831.                                                             iterator last) {
  832.   if (first == begin() && last == end())
  833.     clear();
  834.   else
  835.     while (first != last) erase(first++);
  836. }
  837. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  838. void rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::erase(const Key* first, 
  839.                                                             const Key* last) {
  840.   while (first != last) erase(*first++);
  841. }
  842. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  843. typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::iterator 
  844. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::find(const Key& k) {
  845.   link_type y = header;        // Last node which is not less than k. 
  846.   link_type x = root();        // Current node. 
  847.   while (x != 0) 
  848.     if (!key_compare(key(x), k))
  849.       y = x, x = left(x);
  850.     else
  851.       x = right(x);
  852.   iterator j = iterator(y);   
  853.   return (j == end() || key_compare(k, key(j.node))) ? end() : j;
  854. }
  855. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  856. typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::const_iterator 
  857. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::find(const Key& k) const {
  858.   link_type y = header; /* Last node which is not less than k. */
  859.   link_type x = root(); /* Current node. */
  860.   while (x != 0) {
  861.     if (!key_compare(key(x), k))
  862.       y = x, x = left(x);
  863.     else
  864.       x = right(x);
  865.   }
  866.   const_iterator j = const_iterator(y);   
  867.   return (j == end() || key_compare(k, key(j.node))) ? end() : j;
  868. }
  869. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  870. typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::size_type 
  871. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::count(const Key& k) const {
  872.   pair<const_iterator, const_iterator> p = equal_range(k);
  873.   size_type n = 0;
  874.   distance(p.first, p.second, n);
  875.   return n;
  876. }
  877. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  878. typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::iterator 
  879. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::lower_bound(const Key& k) {
  880.   link_type y = header; /* Last node which is not less than k. */
  881.   link_type x = root(); /* Current node. */
  882.   while (x != 0) 
  883.     if (!key_compare(key(x), k))
  884.       y = x, x = left(x);
  885.     else
  886.       x = right(x);
  887.   return iterator(y);
  888. }
  889. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  890. typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::const_iterator 
  891. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::lower_bound(const Key& k) const {
  892.   link_type y = header; /* Last node which is not less than k. */
  893.   link_type x = root(); /* Current node. */
  894.   while (x != 0) 
  895.     if (!key_compare(key(x), k))
  896.       y = x, x = left(x);
  897.     else
  898.       x = right(x);
  899.   return const_iterator(y);
  900. }
  901. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  902. typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::iterator 
  903. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::upper_bound(const Key& k) {
  904.   link_type y = header; /* Last node which is greater than k. */
  905.   link_type x = root(); /* Current node. */
  906.    while (x != 0) 
  907.      if (key_compare(k, key(x)))
  908.        y = x, x = left(x);
  909.      else
  910.        x = right(x);
  911.    return iterator(y);
  912. }
  913. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  914. typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::const_iterator 
  915. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::upper_bound(const Key& k) const {
  916.   link_type y = header; /* Last node which is greater than k. */
  917.   link_type x = root(); /* Current node. */
  918.    while (x != 0) 
  919.      if (key_compare(k, key(x)))
  920.        y = x, x = left(x);
  921.      else
  922.        x = right(x);
  923.    return const_iterator(y);
  924. }
  925. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  926. inline pair<typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::iterator,
  927.             typename rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::iterator>
  928. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::equal_range(const Key& k) {
  929.   return pair<iterator, iterator>(lower_bound(k), upper_bound(k));
  930. }
  931. template <class Key, class Value, class KoV, class Compare, class Alloc>
  932. inline pair<typename rb_tree<Key, Value, KoV, Compare, Alloc>::const_iterator,
  933.             typename rb_tree<Key, Value, KoV, Compare, Alloc>::const_iterator>
  934. rb_tree<Key, Value, KoV, Compare, Alloc>::equal_range(const Key& k) const {
  935.   return pair<const_iterator,const_iterator>(lower_bound(k), upper_bound(k));
  936. }
  937. inline int __black_count(__rb_tree_node_base* node, __rb_tree_node_base* root)
  938. {
  939.   if (node == 0)
  940.     return 0;
  941.   else {
  942.     int bc = node->color == __rb_tree_black ? 1 : 0;
  943.     if (node == root)
  944.       return bc;
  945.     else
  946.       return bc + __black_count(node->parent, root);
  947.   }
  948. }
  949. template <class Key, class Value, class KeyOfValue, class Compare, class Alloc>
  950. bool 
  951. rb_tree<Key, Value, KeyOfValue, Compare, Alloc>::__rb_verify() const
  952. {
  953.   if (node_count == 0 || begin() == end())
  954.     return node_count == 0 && begin() == end() &&
  955.       header->left == header && header->right == header;
  956.   
  957.   int len = __black_count(leftmost(), root());
  958.   for (const_iterator it = begin(); it != end(); ++it) {
  959.     link_type x = (link_type) it.node;
  960.     link_type L = left(x);
  961.     link_type R = right(x);
  962.     if (x->color == __rb_tree_red)
  963.       if ((L && L->color == __rb_tree_red) ||
  964.           (R && R->color == __rb_tree_red))
  965.         return false;
  966.     if (L && key_compare(key(x), key(L)))
  967.       return false;
  968.     if (R && key_compare(key(R), key(x)))
  969.       return false;
  970.     if (!L && !R && __black_count(x, root()) != len)
  971.       return false;
  972.   }
  973.   if (leftmost() != __rb_tree_node_base::minimum(root()))
  974.     return false;
  975.   if (rightmost() != __rb_tree_node_base::maximum(root()))
  976.     return false;
  977.   return true;
  978. }
  979. __STL_END_NAMESPACE 
  980. #endif /* __SGI_STL_INTERNAL_TREE_H */
  981. // Local Variables:
  982. // mode:C++
  983. // End: