一棵简单的二叉查找树模版类(空闲时间，断断续续写了几天)

#ifndef _LBST_H_
#define _LBST_H_

template<typename _Key,typename _Value>
class LBST 
{
 typedef _Key BST_KEY;
 typedef _Value BST_VALUE;
private:
 class BST_NODE
 {
 public:
  BST_NODE(){_left=_right=_parent=0;}
  BST_NODE(const BST_NODE& other){
   _key=other._key;_value=other._value;_left=_right=_parent=0;
  }
  BST_NODE& operator =(const BST_NODE& other){
   _key=other._key;_value=other._value;_left=_right=_parent=0;
  }
  BST_KEY _key;
  BST_VALUE _value;
  BST_NODE *_left,*_right,*_parent;
 };
public:
 class iterator{
  typedef BST_NODE* nodePtr;
 public:
  iterator(){_node=0;_lnode=0;}
  iterator(nodePtr node,nodePtr lnode=0){_node=node;_lnode=lnode;}
  iterator(const iterator& other){_node=other._node;_lnode=other._lnode;}
  iterator& operator =(const iterator& other){
   _node=other._node;_lnode=other._lnode;return *this;
  }
  nodePtr& operator ->(){return _node;}
  iterator& operator ++(){
   _lnode=_node;
   if(_node->_right==0){
    nodePtr _op=_node->_parent;
    while(_op&&_op->_right==_node){_node=_op;_op=_op->_parent;}
    _node=_op;
   }else{
    nodePtr _op=_node->_right;
    while(_op){_node=_op;_op=_op->_left;}
   }
   return *this;
  }
  iterator& operator --(){
   _lnode=_node;
   if(_node->_left){
    nodePtr _op=_node->_left;
    while(_op){_node=_op;_op=_op->_right;}
   }else{
    nodePtr _op=_node->_parent;
    while(_op&&_op->_left==_node){_node=_op;_op=_op->_parent;}
    _node=_op;
   }
   return *this;
  }
  iterator operator --(int){
   nodePtr _Tmp=_lnode;operator --();return iterator(_lnode,_Tmp);
  }
  iterator operator ++(int){
   nodePtr _Tmp=_lnode;operator ++();return iterator(_lnode,_Tmp);
  }
  bool operator ==(const iterator& other){return _lnode==other._node;}
  bool operator !=(const iterator& other){return _lnode!=other._node;}
 private:
  nodePtr _node,_lnode;
 };
public:
 LBST(){_root=_begin=_end=0;_size=0;}
 virtual ~LBST(){clear();}
 int size(){return _size;}
 iterator begin(){return iterator(_begin);}
 iterator end(){return iterator(_end);}
 BST_VALUE& operator [](const BST_KEY& key){
  BST_NODE *_op,*_last;
  if(_op=search_node(key,_last))return _op->_value;
  return insert_node(key,BST_VALUE(),_last)->_value;
 }
 void insert(const BST_KEY& key,const BST_VALUE& value){
  insert_node(key,value,0);
 }
 void erase(const BST_KEY& key){
  BST_NODE *_op,*_last;
  if(_op=search_node(key,_last))erase_node(_op);
 }
 void clear(){
  BST_NODE *_op=_root,*_tmp;
  while(_op){
   if(_op->_left)_op=_op->_left;
   else if(_op->_right)_op=_op->_right;
   else{
    if(_op->_parent){
     if(_op->_parent->_left==_op)_op->_parent->_left=0;
     else _op->_parent->_right=0;
    }
    _tmp=_op;_op=_op->_parent;delete _tmp;
   }
  }
  _root=_begin=_end=0;
 }
protected:
 BST_NODE *_root,*_begin,*_end;
 int _size;
 BST_NODE* search_node(const BST_KEY& key,BST_NODE*& last){
  BST_NODE *_op=_root;last=_op;
  while(_op){
   last=_op;
   if(_op->_key>key)_op=_op->_left;
   else if(_op->_key<key)_op=_op->_right;
   else break;
  }
  return _op;
 }
 BST_NODE* insert_node(const BST_KEY& key,const BST_VALUE& value,BST_NODE* _last=0){
  BST_NODE *_op;
  if(_last==0){
   if(_op=search_node(key,_last)){_op->_value=value;return _op;}
  }
  _op=new BST_NODE;_op->_key=key;_op->_value=value;
  if(_last==0)_root=_begin=_end=_op;
  else if(_last->_key>key){
   _last->_left=_op;_op->_parent=_last;
   if(_last==_begin)_begin=_op;
  }else{
   _last->_right=_op;_op->_parent=_last;
   if(_end==_last)_end=_op;
  }
  _size++;return _op;
 }
 void erase_node(BST_NODE* node){
  BST_NODE *_new;
  if(node->_left){
   if(node->_right){
    BST_NODE *_op=node->_right;
    while(_op){_new=_op;_op=_op->_left;}
    _new->_left=node->_left;
    if(_new->_left)_new->_left->_parent=_new;
    _new=node->_right;
   }else _new=node->_left;
  }else _new=node->_right;
  if(_new)_new->_parent=node->_parent;
  if(node->_parent){
   if(node==node->_parent->_left)node->_parent->_left=_new;
   else node->_parent->_right=_new;
  }else _root=_new;
  if(_begin==node)_begin=node->_parent;if(!_begin)_begin=_new;
  if(_end==node)_end=node->_parent;if(!_end)_end=_new;
  delete node;_size--;
 } 
};

#endif