实现一个简单的二叉树

　　之前刷题的时候，很多类似二叉树的题，但是千变万化，基本上都是几种遍历，反转，求高度这些的变形或者组合，所以这里索性直接写一个得了：

　　首先是二叉树的节点：

template<typename T>
struct TreeNode{
    T val;
    TreeNode<T> * left;
    TreeNode<T> * right;
    TreeNode();
    TreeNode(const T & x);
    ~TreeNode(); // non trivial destructor
};

　　注意destructor需要自己去实现一下:

template<typename T>
TreeNode<T>::~TreeNode()
{
    delete left;
    delete right;
    left = right = NULL;
}

　　其他的没什么，直接贴代码：

template<typename T>
TreeNode<T>::TreeNode()
{
    left = right = NULL;
}

template<typename T>
TreeNode<T>::TreeNode(const T & x)
{
    left = right = NULL;
    val = x;
}

　　之后就是树的定义了，考虑到封装，将底层的操作交给一些private方法去做，使用public的方法再去调用这些方法，所有声明如下所示：

template<typename T>
class BinaryTree{
    typedef void(*pFunc)(T &);
public:
    BinaryTree() :root(NULL){}
    ~BinaryTree(); //non-trival destructor
    BinaryTree(std::initializer_list<T> il); //use initializer to construct
    BinaryTree(const BinaryTree<T> & rhs); // cp constructor
    BinaryTree<T> & operator=(const BinaryTree<T> & rhs); // = operator
    const TreeNode<T> * getRoot() const; 
    bool empty()const; // check empty
    void preOrder(pFunc fun); 
    void inOrder(pFunc fun);
    void postOrder(pFunc fun);
    void insert(const T & x);// add new number to the tree
    int size()const; // get node total number in tree
    int height()const; // get height of tree
    void invert(); //invert the tree

private:
    int size(const TreeNode<T> * root)const;
    int height(const TreeNode<T> * root)const;
    bool empty(const TreeNode<T> * root)const;
    bool equal(const TreeNode<T> * left, const TreeNode<T> * right)const;    
    void assign(TreeNode<T> * & lhs, const TreeNode<T> * rhs);
    void invert(TreeNode<T> * & root);
    void clear(TreeNode<T> * & root);
    void insert(TreeNode<T> * & root, const T & x);
    void preOrder(TreeNode<T> * root, pFunc fun);
    void inOrder(const TreeNode<T> * root, pFunc fun);
    void postOrder(const TreeNode<T> * root, pFunc fun);
private:
    TreeNode<T> * root;
};

assign, invert, clear, insert 这几个用到了引用。这里必须用引用，负责传过来的是指针的副本。

下面是具体的定义：

template<typename T>
int BinaryTree<T>::size(const TreeNode<T> * root)const
{
    if (root == NULL)
        return 0;
    else 
        return 1 + size(root->left) + size(root->right);
}

template<typename T>
int BinaryTree<T>::height(const TreeNode<T> * root)const
{
    if (root == NULL)
        return 0;
    else
        return 1 + max(height(root->left    ), height(root->right));
}

template<typename T>
bool BinaryTree<T>::equal(const TreeNode<T> * lhs, const TreeNode<T> *rhs)const
{
    if (lhs == NULL && rhs == NULL)
        return true;
    if (lhs != NULL && rhs != NULL){
        if (lhs->val != rhs->val)
            return false;
        else
            return equal(lhs->left, rhs->left) && equal(lhs->right, rhs->right);
    }
    else{ // left与right中有一者是NULL
        return false;
    }
}

template<typename T>
bool BinaryTree<T>::empty(const TreeNode<T> * root)const
{
    return root == NULL;
}

template<typename T>
void BinaryTree<T>::assign(TreeNode<T> * & lhs, const TreeNode<T> * rhs)
{
    if (empty(rhs))
        lhs = new TreeNode<T>(rhs->val);
    if (rhs->left != NULL)
        assign(lhs->left, rhs->left);
    if (rhs->right != NULL)
        assign(lhs->right, rhs->right);
}

template<typename T>
void BinaryTree<T>::invert(TreeNode<T> * & root)
{
    if (root == NULL)
        return;
    swap(root->left, root->right);
    invert(root->left);
    invert(root->right);
}

template<typename T>
void BinaryTree<T>::clear(TreeNode<T> * & root)
{
    if (root == NULL)
        return;
    clear(root->left);
    clear(root->right);
    delete root;
    root = NULL;
}

template<typename T>
void BinaryTree<T>::insert(TreeNode<T> * & root, const T & x)
{
    if (root == NULL){
        root = new TreeNode<T>(x);
        return;
    }
    else{
        if (height(root->left) <= height(root->right)){
            insert(root->left, x);
        }
        else{
            insert(root->right, x);
        }
    }
}

template<typename T>
void BinaryTree<T>::preOrder(TreeNode<T> * root, pFunc fun)
{
    if (root == NULL)
        return;
    fun(root->val);
    preOrder(root->left, fun);
    preOrder(root->right, fun);
}

template <typename T>
void BinaryTree<T>::inOrder(const TreeNode<T> * root, pFunc fun)
{
    if (root == NULL)
        return;
    inOrder(root->left);
    fun(root->val);
    inOrder(root->right);
}

template<typename T>
void BinaryTree<T>::postOrder(const TreeNode<T> * root, pFunc fun)
{
    if (root == NULL)
        return;
    postOrder(root->left);
    postOrder(root->right);
    fun(root->val);
}

template<typename T>
BinaryTree<T>::~BinaryTree()
{
    clear(this->root);
}

template<typename T>
BinaryTree<T>::BinaryTree(const BinaryTree<T> & rhs)
{
    if (this == &rhs)
        return;
    else
        assign(this->root, rhs.root);
}

template<typename T>
BinaryTree<T> & BinaryTree<T>::operator=(const BinaryTree<T> & rhs)
{
    if (this == &rhs)
        return *this;
    assign(this->root, rhs.root);
    return *this;
}

template<typename T>
const TreeNode<T> * BinaryTree<T>::getRoot()const
{
    return root;
}

template<typename T>
bool BinaryTree<T>::empty()const
{
    return empty(this->root);
}

template<typename T>
void BinaryTree<T>::preOrder(pFunc fun)
{
    preOrder(this->root, fun);
}


template<typename T>
void BinaryTree<T>::inOrder(pFunc fun)
{
    inOrder(this->root, fun);
}

template<typename T>
void BinaryTree<T>::postOrder(pFunc fun)
{
    postOrder(this->root, fun);
}

template<typename T>
int BinaryTree<T>::size()const
{
    return size(this->root);
}

template<typename T>
int BinaryTree<T>::height()const
{
    return height(this->root);
}

template<typename T>
void BinaryTree<T>::invert()
{
    invert(this->root);
}

template<typename T>
void BinaryTree<T>::insert(const T & x)
{
    insert(this->root, x);
}


template<typename T>
BinaryTree<T>::BinaryTree(std::initializer_list<T> il)
    :root(NULL)
{
    for (T i : il){
        insert(i);
    }
}


void tranverseFunc(int & val)
{
    cout << "#:" << val << endl;
}

下面可以造一个实例使用一下：

int main()
{
    BinaryTree<int> tree{1,4,3,6,3,2,8,7,11,25};
    tree.preOrder(tranverseFunc);
    tree.invert();
    cout << "Invert 之后的树为： " << endl;
    tree.preOrder(tranverseFunc);
    system("pause");
}