C++写二叉树

在代码中都是使用的是递归来遍历二叉树，在这里面的代码中主要测试的是二叉树的插入和遍历insert()和preOrder(),inOrder(),postOrder();

#include<iostream>
using namespace std;
template <class Type> class BinaryTree;
template <class Type> class BinTreeNode {
    friend class BinaryTree<Type>;
public:
    BinTreeNode() :leftChild(NULL), rightChild(NULL) {}
    BinTreeNode(Type item, BinTreeNode<Type> *left = NULL,
        BinTreeNode<Type> *right = NULL) :
        data(item), leftChild(left), rightChild(right) {}
    Type GetData()const { return data; }
    BinTreeNode<Type> *GetLeft()const { return leftChild; }
    BinTreeNode<Type> *GetRight()const { return rightChild; }
    void setData(const Type &item) { data = item; }
    void SetLeft(BinTreeNode <Type>*L) { leftChild = L; }
    void SetRight(BinTreeNode<Type> *R) { rightChild = R; }
private:
    BinTreeNode<Type> *leftChild, *rightChild;
    Type data;

};
template<class Type> class BinaryTree {
public:
    BinaryTree() :root(NULL) {}
    BinaryTree(Type value) :RefValue(value), root(NULL) {}
    virtual ~BinaryTree() { destroy(root); }
    virtual int IsEmpty() {
        return root == NULL ? 1 : 0;
    }
    virtual BinTreeNode<Type> *Parent(BinTreeNode<Type>* current) {
        return root == NULL || root == current ? NULL : Parent(root, current);
    }
    virtual BinTreeNode <Type> *LeftChild(BinTreeNode<Type>*current) {
        return current != NULL ? current->leftChild : NULL;
    }
    virtual BinTreeNode<Type> *RightChild(BinTreeNode<Type> *current) {
        return current != NULL ? current->rightChild : NULL;
    }
    bool Insert(const Type &item);
//  virtual int Find(const Type &item)const;
    BinTreeNode<Type> *GetRoot()const { return root; }
    friend istream & operator >> (istream &in, BinaryTree<Type> &Tree);
    friend ostream & operator << (ostream &out, BinaryTree<Type> &Tree);
public:
    BinTreeNode<Type> *root;
    Type RefValue;
    BinTreeNode<Type> *Parent(BinTreeNode<Type>*start,
        BinTreeNode<Type>*current); 
    void preOrder(BinTreeNode<Type> *current); 
    void inOrder(BinTreeNode<Type> *current);
    void postOrder(BinTreeNode<Type> *current);
    void destroy(BinTreeNode<Type> *current);

};
template<class Type> void BinaryTree<Type>::destroy(BinTreeNode<Type>*current) {
    if (current != NULL) {
        destroy(current->leftChild);
        destroy(current->rightChild);
        delete current;
    }
}
template<class Type> bool BinaryTree<Type>::Insert(const Type &item) {
    if (root == NULL) {
        root = new BinTreeNode<Type>(item);
    }
    else {
        BinTreeNode<Type> *parent = NULL;
        BinTreeNode<Type>  *p = root;
        while (p != NULL) {
            if (item<p->data) {
                parent = p;
                p = p->leftChild;
            }
            else if (item>p->data) {
                parent = p;
                p = p->rightChild;
            }
            else {
                return false;
            }
        }
        if (item<parent->data)
            parent->leftChild = new BinTreeNode<Type>(item);
        else
            parent->rightChild = new BinTreeNode<Type>(item);
    }
    return true;
}
//寻找parent节点
template <class Type> BinTreeNode <Type> * BinaryTree <Type> ::Parent(BinTreeNode
    <Type> * start, BinTreeNode <Type> *current) {
    if (start == NULL) return NULL;
    if (start->leftChild == current ||
        start->rightChild == current)
        return start;
    BinTreeNode <Type> *p;
    if ((p = Parent(start->leftChild, current))
        != NULL) return p;
    else return Parent(start->rightChild, current);
}
//将二叉树输出
template <class Type> void BinaryTree<Type>::preOrder(
    BinTreeNode <Type> *current){

    if (current != NULL) {
        cout << current->data << ' ';
        preOrder(current->leftChild);
        preOrder(current->rightChild);
    }
}
template <class Type> void BinaryTree<Type>::inOrder(BinTreeNode <Type> *current) {

    if (current != NULL) {

        inOrder(current->leftChild);
        cout << current->data << ' ';
        inOrder(current->rightChild);
    }
}
template <class Type> void BinaryTree<Type>::postOrder(BinTreeNode <Type> *current) {

    if (current != NULL) {

        postOrder(current->leftChild);

        postOrder(current->rightChild);
        cout << current->data << ' ';
    }
}

template <class Type> istream & operator >> (istream & in, BinaryTree<Type> &Tree) {
    Type item;
    cout << "构造二叉树 : \n ";
    cout << "输入数据 ( 用 " << Tree.RefValue
        << "结束 ): ";
    in >> item;
    while (item != Tree.RefValue) {
        Tree.Insert(item);
        cout << "输入数据 ( 用 " << Tree.RefValue
            << "结束 ): ";
        in >> item;
    }
    return in;
}
template <class Type> ostream & operator << (ostream &out, BinaryTree<Type> &Tree) {
    out << "二叉树的前序遍历.\n";
    Tree.Traverse(Tree.root, out);
    out << endl;
    return out;
}
int main() {
    BinaryTree<int> BT;
    BT.Insert(4);
    BT.Insert(3);
    BT.Insert(5); 
    BT.Insert(2);
    BT.Insert(6); 
    cout << BT.GetRoot()->GetData() << endl;
    BT.preOrder(BT.GetRoot()); 
    cout << endl;
    BT.inOrder(BT.GetRoot());
    cout << endl;
    BT.postOrder(BT.GetRoot());
    cout << endl;
    getchar();
    return 0;
}