[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_ptrparent;base_ptrleft;base_ptrright;// search the minstatic base_ptr minimum( base_ptr x ){// wait for added}// search the maxstatic 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;Valuevalue_field;};/* The base iterator */struct _bstree_iterator_base{typedef _bstree_node_base::base_ptrbase_ptr;typedef std::bidirectional_iterator_tagiterator_category;typedef ptrdiff_tdifference_type;/* a node to a tree node */base_ptrnode;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 Valuevalue_type;typedef Refreference;typedef Ptrpointer;typedef _bstree_node::link_typelink_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 Keykey_type;typedef Valuevalue_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_tsize_type;typedef ptrdiff_tdifference_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 nodelink_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_typenode_count;link_typeheader;Comparekey_compare;/// the next three functions use to get info about the tree headerlink_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 nodestatic 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 referencevalue( 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 referencevalue( 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--midorderlystatic link_typeminimum( link_type x ){ return (link_type)_bstree_node_base::minimum( x ); }static link_typemaximum( link_type x ){ return (link_type)_bstree_node_base::maximun( x ); }private:/// the init function -- only use internalvoid 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 treeBSTree( const Compare& comp = Compare() ) : node_count(0), key_compare(comp) { init( ); }/// constructor -- a copy of another treeBSTree( const BSTree< Value, Key, KeyOfValue, Compare, Alloc >& x ): node_count(0), key_compare(x.key_compare){if( x.root() == 0 ) {//x is an empty treeinit();} 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 earsestd::pair< iterator,bool>insert_unique( const value_type& x );// the node are diffiterator insert_equal( const value_type&x );// maybe sameiterator insert_unique( iterator position, const value_type &x );iterator insert_equal( iterator position, const value_type &x );#ifdef __STL_MEMBER_TEMPLATEStemplate< class InputIterator >void insert_unique( InputIterator first, InputIterator last );template< class InputIterator >void insert_equal( InputIterator first, InputIterator last );#elsevoid 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 );#endifvoid 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_typeBSTree< Value, Key, KeyOfValue, Compare, Alloc >::_copy( link_type x, link_type y ){// assume the x and y both are non-nulllink_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 valuetemplate < class Value, class Key, class KeyOfValue, class Compare, class Alloc >typename BSTree< Value, Key, KeyOfValue, Compare, Alloc >::iteratorBSTree< 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 >::iteratorBSTree< 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++来写个什么东西总是很冗长，写久了就难免心生厌烦。大家都在努力的使语言更具有表现力，用更少的代码做更多的事情，不过我倒觉得，终极的改进方法应该是实现人机对话，这样什么什么都好解决了。

 

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