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=0,
            TreeNode<T>* left=0,
            TreeNode<T>* right=0)
        :_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(1) { }
    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,0);
}

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

二叉搜索树