[BSTree] 二叉搜索树 -- C++ 模板实现

最近研究C++模板编程，参看了《STL源码剖析》之类的书，深深的感慨，模板这玩意真够神奇的。

实现了一个二叉搜索树的模板。但并不算完善，以后的编码多是一些算法的具体的实现。就模板技术来说，已搭建完毕。一瞬间失去了新鲜感，于是觉得没有再写下去的必要了。因相关算法在当年学习数据结构时候已实现过N次了……当年是用C来实现的，后来想尽办法想让我的程序更加的灵活更加的可复用，可惜当初有些抵触C++，没有想到有更好的办法。

以下是代码。

 

#pragma once #ifndef _BINSEARCHTREE_H #define _BINSEARCHTREE_H #include <functional> #include <utility> #include "simple_alloc.h" #include "functors.h" /* The tree node base */ struct _bstree_node_base { typedef _bstree_node_base* base_ptr; base_ptr parent; base_ptr left; base_ptr right; // search the min static base_ptr minimum( base_ptr x ) { // wait for added } // search the max static base_ptr maximun( base_ptr x ) { // wait for added } }; /* The compelete tree node */ template < class Value > struct _bstree_node : public _bstree_node_base { typedef _bstree_node< Value >* link_type; Value value_field; }; /* The base iterator */ struct _bstree_iterator_base { typedef _bstree_node_base::base_ptr base_ptr; typedef std::bidirectional_iterator_tag iterator_category; typedef ptrdiff_t difference_type; /* a node to a tree node */ base_ptr node; void increment( ) { // wait for added } void decrement( ) { // wait for added } }; /* The iterator */ template < class Value, class Ref, class Ptr > struct _bstree_iterator : public _bstree_iterator_base { typedef Value value_type; typedef Ref reference; typedef Ptr pointer; typedef _bstree_node::link_type link_type; typedef _bstree_iterator< Value, Ref, Ptr > self; typedef _bstree_iterator< Value, Value&, Value* > iterator; typedef _bstree_iterator< Value, const Value&, const Value* > const_iterator; _bstree_iterator( ) { } _bstree_iterator( link_type x ) : node(x) { } _bstree_iterator( const iterator& x ) : node(x.node) { } reference operator *( ) const { return link_type(node)->value_field; } // mark // to be added from here }; /* The bstree */ template < class Value, class Key = Value, class KeyOfValue = identity<Value>, class Compare = less<Key>, class Alloc = allocator<_bstree_node< Value >> > class BSTree { protected: typedef void* PVOID; typedef _bstree_node_base* base_ptr; typedef _bstree_node< Value > bstree_node; typedef simple_alloc< bstree_node, Alloc > simple_alloc_for_bstree; simple_alloc_for_bstree _bstree_node_allocator; 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 bstree_node* link_type; typedef size_t size_type; typedef ptrdiff_t difference_type; /// the iterator for outside call; typedef _bstree_iterator< value_type, reference, pointer > iterator; typedef _bstree_iterator< value_type, const_reference, const_pointer > const_iterator; protected: /// the next five function use for allocate about the node link_type get_node( ) { return _bstree_node_allocator.allocate( ); } void put_node( link_type p ) { _bstree_node_allocator.deallocate( p ); } link_type create_node( const value_type &x ) { link_type tmp = get_node( ); __try { construct( &tmp->value_field, x ); } __except { put_node(tmp); } return tmp; } link_type clone_node( link_type x ) { link_type tmp = create_node( x->value_field ); tmp->left = 0; tmp->right = 0; return tmp; } void destroy_node( link_type x ) { destroy( &x->value_field ); put_node( x ); } protected: size_type node_count; link_type header; Compare key_compare; /// the next three functions use to get info about the tree header 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; } /// the next eight functions use to get the info about the node 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 (link_type&)(x->value_field); } static const Key& key( link_type x ) { return KeyOfValue()( (value)x ); } 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 ); } /// get the max and min--midorderly static link_type minimum( link_type x ) { return (link_type)_bstree_node_base::minimum( x ); } static link_type maximum( link_type x ) { return (link_type)_bstree_node_base::maximun( x ); } private: /// the init function -- only use internal void init( ) { header = get_node( ); root( ) = 0; leftmost( ) = header; rightmost( ) = header; } void clear( ) { if( 0 != node_count ) { _erase( root() ); leftmost() = header; root() = 0; rightmost() = header; node_count = 0; } } void _erase( link_type x ); link_type _copy( link_type x, link_type y ); iterator _insert( base_ptr _x, base_ptr _y, const value_type &v ); public: /// default constructor -- for an empty tree BSTree( const Compare& comp = Compare() ) : node_count(0), key_compare(comp) { init( ); } /// constructor -- a copy of another tree BSTree( const BSTree< Value, Key, KeyOfValue, Compare, Alloc >& x ) : node_count(0), key_compare(x.key_compare) { if( x.root() == 0 ) { //x is an empty tree init(); } else { header = get_node(); __try { _copy( x.root(), header ); } __except { put_node( header ); } leftmost() = minimum( root() ); rightmost() = maximum( root() ); } node_count = x.node_count; } /// overload the operator = BSTree< Value, Key, KeyOfValue, Compare, Alloc >& operator = ( const BSTree< Value, Key, KeyOfValue, Compare, Alloc >& x ); ~BSTree() { clear( ); put_node( header ); } Compare key_comp() const { return key_compare; } iterator begin() { return leftmost(); } iterator end() { return header; } bool isempty() { return node_count == 0;} size_type size() const { return node_count; } size_type length() const { return node_count; } size_type max_size() const { return size_type(-1); } void swap( BSTree< Value, Key, KeyOfValue, Compare, Alloc >& x ) { std::swap( header, x.header ); std::swap( node_count, x.node_count ); std::swap( key_compare, x.key_compare ); } const link_type& findmax() const { return maximum(root()); } const link_type& findmin() const { return minimum(root()); } bool contains( const link_type &x, link_type &root = root() ) const { return contains( key(x), root ); } bool contains(const key_type &x, link_type &root = root() ) const; void makeEmpty( link_type root ) { clear(); } public: /// the next are functions to insert or earse std::pair< iterator,bool> insert_unique( const value_type& x ); // the node are diff iterator insert_equal( const value_type&x ); // maybe same iterator insert_unique( iterator position, const value_type &x ); iterator insert_equal( iterator position, const value_type &x ); #ifdef __STL_MEMBER_TEMPLATES template< class InputIterator > void insert_unique( InputIterator first, InputIterator last ); template< class InputIterator > void insert_equal( InputIterator first, InputIterator last ); #else void insert_unique( const_iterator first, const_iterator last ); void insert_unique( const value_type* first, const value_type* last ); void insert_equal( const_iterator first, const_iterator last ); void insert_equal( const value_type* first, const value_type* last ); #endif void erase( iterator position ); size_type erase( const key_type &x ); void erase( iterator first, iterator last ); void erase( const key_type* first, const key_type* last ); }; //--------------------------------------------------------------------------------------- /*-------------- The template functions used in the above class template -------------*/ //------------------------------------------------------------------------------------- template< class Value, class Key, class KeyOfValue, class Compare, class Alloc > inline bool operator == ( const BSTree< Value, Key, KeyOfValue, Compare, Alloc > &x, const BSTree< Value, Key, KeyOfValue, Compare, Alloc > &y ) { return (x.size() == y.size()) && ( equal(x.begin(), x.end(), y.begin(), key_compare ) ); } template< class Value, class Key, class KeyOfValue, class Compare, class Alloc > inline bool operator < ( const BSTree< Value, Key, KeyOfValue, Compare, Alloc > &x, const BSTree< Value, Key, KeyOfValue, Compare, Alloc > &y ) { return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), key_compare); } template < class Value, class Key, class KeyOfValue, class Compare, class Alloc > inline void swap( const BSTree< Value, Key, KeyOfValue, Compare, Alloc > &x, const BSTree< Value, Key, KeyOfValue, Compare, Alloc > &y ) { x.swap( y ); } template < class Value, class Key, class KeyOfValue, class Compare, class Alloc > void BSTree< Value, Key, KeyOfValue, Compare, Alloc >::_erase( link_type x ) { while( 0 != x ) { _erase( right(x) ); link_type y = left(x); destroy_node( x ); x = y; } } template < class Value, class Key, class KeyOfValue, class Compare, class Alloc > typename BSTree< Value, Key, KeyOfValue, Compare, Alloc >::link_type BSTree< Value, Key, KeyOfValue, Compare, Alloc >::_copy( link_type x, link_type y ) { // assume the x and y both are non-null link_type top = clone_node(x); top->parent = y; __try { if( x->right ) top->right = _copy( right(x), top ); y = top; x = left(x); while( x != 0 ) { link_type z = clone_node(x): y->left = z; z->parent = y; if( x->right ) z->right = _copy( right(x), z ); y = z; x = left(x); } } __except { _earse(top); } return top; } template < class Value, class Key, class KeyOfValue, class Compare, class Alloc > BSTree< Value, Key, KeyOfValue, Compare, Alloc >& BSTree< Value, Key, KeyOfValue, Compare, Alloc >:: operator = ( const BSTree< Value, Key, KeyOfValue, Compare, Alloc >& x ) { if( this != &x ) { clear(); node_count = 0; key_compare = x.key_compare; if( x.root() == 0 ) { root() = 0; leftmost() = header; rightmost() = header; } } else { root() = _copy( x.root(), header ); leftmost = minimum( root() ); rightmost = maximum( root() ); node_count = x.node_count; } return *this; } /// insert -- the real one to insert the node into the tree /// this one will be called by other insert functions and use only internal /// here the _x is the position to insert, _y is the parent of _y, v is the new value template < class Value, class Key, class KeyOfValue, class Compare, class Alloc > typename BSTree< Value, Key, KeyOfValue, Compare, Alloc >::iterator BSTree< Value, Key, KeyOfValue, Compare, Alloc >::_insert( base_ptr _x, base_ptr _y, const value_type &v ) { link_type x = (link_type)_x; link_type y = (link_type)_y; link_type z; if( (y == header) || (x != 0) || (key_compare( KeyOfValue()(v), key(y) )) ) { z = create_node( v ); left(y) = z; if( y == header ) { root() = z; rightmost() = z; } else if( y == leftmost() ) { leftmost() = z; } } else { z = create_node(v); right(y) = z; if( y == rightmost() ) rightmost() = z; } parent(z) = y; left(z) = 0; right(z) = 0; node_count++; return iterator(z); } template < class Value, class Key, class KeyOfValue, class Compare, class Alloc > typename BSTree< Value, Key, KeyOfValue, Compare, Alloc >::iterator BSTree< Value, Key, KeyOfValue, Compare, Alloc >::insert_equal( const value_type &v ) { link_type y = header; link_type x = root(); while( x != 0 ) { y =x; x = key_compare(KeyOfValue()(v), key(x)) ? left(x) : right(x); } return __insert(x, y, v); } template < class Value, class Key, class KeyOfValue, class Compare, class Alloc > std::pair< typename BSTree< Value, Key, KeyOfValue, Compare, Alloc >::iterator, bool > BSTree< Value, Key, KeyOfValue, Compare, Alloc >::insert_unique( const value_type &v ) { link_type x = header; link_type y = root(); bool cmp = true; while( x != 0 ) { y = x; comp = key_compare( KeyOfValue()(v), key(x) ); x = cmp? left(x) : right(x); } iterator ite = iterator(y); if(cmp) { if( ite == begin() ) return pair<iterator,bool>(_insert(x, y, v), true); else --ite; } if (key_compare( key(ite.node), KeyOfValue()(v)) ) return pair<iterator,bool>(_insert(x, y, v), true); return pair<iterator,bool>(ite, false); } // more insert functions should be continue from here ... template < class Value, class Key, class KeyOfValue, class Compare, class Alloc > bool BSTree< Value, Key, KeyOfValue, Compare, Alloc >::contains( const key_type &x, link_type &root ) const { if( NULL == root ) { return false; } else if( key_compare(x,key(root) ) ) { return contains( x, left(root) ); } else if( !key_compare(x,key(root) ) ){ return contains( x, right(root) ); } else { return ture; } } #endif

 

如果完全写完，到千行是轻易而举的事情。这也让我深深的体会到，用C++来写个什么东西总是很冗长，写久了就难免心生厌烦。大家都在努力的使语言更具有表现力，用更少的代码做更多的事情，不过我倒觉得，终极的改进方法应该是实现人机对话，这样什么什么都好解决了。

 

这次学到很多东西，也严重的看到了自己的不足。