Binary search tree

 #ifndef __TREE_H
 #define __TREE_H
 #include <iostream>

 template<typename T> class TreeNode {
 private:
     T             _data;
     TreeNode<T>* _left;
     TreeNode<T>* _right;
     TreeNode<T>* _parent;
 public:
     TreeNode(T data,
             TreeNode<T>* parent=,
             TreeNode<T>* left=,
             TreeNode<T>* right=)
         :_data(data),_parent(parent),_left(left),_right(right) {}
     void insertAtLeft(T data);
     void insertAtRight(T data);
     T& getData();
     TreeNode<T>*& getLeft();
     TreeNode<T>*& getRight();
     TreeNode<T>*& getParent();
 };

 template<typename T>
 T& TreeNode<T>::getData()
 {
     return _data;
 }

 template<typename T>
 TreeNode<T>*& TreeNode<T>::getLeft()
 {
     return _left;
 }

 template<typename T>
 TreeNode<T>*& TreeNode<T>::getRight()
 {
     return _right;
 }

 template<typename T>
 TreeNode<T>*& TreeNode<T>::getParent()
 {
     return _parent;
 }

 template<typename T>
 void TreeNode<T>::insertAtLeft(T data)
 {
     _left = new TreeNode(data,this);
 }

 template<typename T>
 void TreeNode<T>::insertAtRight(T data)
 {
     _right = new TreeNode(data,this);
 }

 template <typename T> class Tree{
 private:
     TreeNode<T>* _root;
     int          _size;
 protected:
     TreeNode<T>* findIn(TreeNode<T>* position,T element) const;
     /*
      * The last tmp argument is necessary,
      * it is used here to changed the parent's _left/_right field
      * to potint the node which is created
      */
     TreeNode<T>* insertIn(TreeNode<T>* position,
             T element,TreeNode<T>* tmp);
     void travIn(TreeNode<T>* position);
     void travPrev(TreeNode<T>* position);
     void travPost(TreeNode<T>* position);
 public:
     Tree(T data)
         :_root(new TreeNode<T> (data)),_size() { }
     TreeNode<T>* find(T element) const;
     TreeNode<T>* findMax() const;
     TreeNode<T>* findMin() const;
     TreeNode<T>* insert(T data);
     void traversalIn();
     void traversalPrev();
     void traversalPost();
 };

 template<typename T>
 void Tree<T>::travIn(TreeNode<T>* position)
 {
     if(!position)
         return ;
     travIn(position->getLeft());
     std::cout << position->getData() << " ";
     travIn(position->getRight());
 }

 template<typename T>
 void Tree<T>::travPrev(TreeNode<T>* position)
 {
     if(!position)
         return ;
     std::cout << position->getData() << " ";
     travPrev(position->getLeft());
     travPrev(position->getRight());
 }

 template<typename T>
 void Tree<T>::travPost(TreeNode<T>* position)
 {
     if(!position)
         return ;
     travPost(position->getLeft());
     travPost(position->getRight());
     std::cout << position->getData() << " ";
 }

 template<typename T>
 void Tree<T>::traversalPost()
 {
     travPost(_root);
     std::cout << std::endl;
 }

 template<typename T>
 void Tree<T>::traversalPrev()
 {
     travPrev(_root);
     std::cout << std::endl;
 }

 template<typename T>
 void Tree<T>::traversalIn()
 {
     travIn(_root);
     std::cout << std::endl;
 }

 template<typename T>
 TreeNode<T>* Tree<T>::insertIn(TreeNode<T>* position,T data,
         TreeNode<T>* tmp)
 {
     if(!position){
         if(!tmp)
             return new TreeNode<T>(data);
         else
             return (tmp->getData() >data ? tmp->getLeft():tmp->getRight())
                 = new TreeNode<T>(data,tmp);
     }
     if(data < position->getData())
         insertIn(position->getLeft(),data,position);
     else if(position->getData() < data)
         insertIn(position->getRight(),data,position);
     else
         return position;
 }
 template<typename T>
 TreeNode<T>* Tree<T>::insert(T data)
 {
     return insertIn(_root,data,);
 }

 template<typename T>
 TreeNode<T>* Tree<T>::findIn(TreeNode<T>* position,T data)const
 {
     while(position && position->getData() != data)
     {
         if(position->getData() > data)
             position = position->getLeft();
         else if(position->getData() < data)
             position = position->getRight();
     }
     return position;
 }

 template<typename T>
 TreeNode<T>* Tree<T>::find(T data) const
 {
     return findIn(_root,data);
 }

 template<typename T>
 TreeNode<T>* Tree<T>::findMax() const
 {
     TreeNode<T>* tmp = _root;
     while(tmp->getRight())
         tmp = tmp->getRight();
     return tmp;
 }

 template<typename T>
 TreeNode<T>* Tree<T>::findMin() const
 {
     TreeNode<T>* tmp = _root;
     while(tmp->getLeft())
         tmp = tmp->getLeft();
     return tmp;
 }

 #endif

二叉搜索树