二叉树的链式实现

二叉树的定义见：二叉树实现：公式化描述

二叉树最常用的描述方法是用链表或指针。每个元素都用一个有两个指针域的节点表示，这两个域为 L e f t C h i l d和R i g h t C h i d。除此两个指针域外，每个节点还有一个 d a t a域。
二叉树的边可用一个从父节点到子节点的指针来描述。指针放在父节点的指针域中。因为包括n 个元素的二叉树恰有 n- 1 条边，因此将有2n- (n- 1 ) =n+ 1 个指针域没有值，这些域被置为0。

节点类：

template<class T>
class BinaryTreeNode
{
    friend class BinaryTree<T>;
public:
    //构造函数
    BinaryTreeNode(){ LeftChild = RightChild = 0; }
    BinaryTreeNode(const T& e){ data = e; LeftChild = RightChild = 0; }
    BinaryTreeNode(const T& e, BinaryTreeNode *l, BinaryTreeNode *r)
    {
        data = e;
        LeftChild = l;
        RightChild = r;
    }
private:
    T data;
    BinaryTreeNode<T> *LeftChild;//左子树
    BinaryTreeNode<T> *RightChild;//右子树
};

二叉树：

template<class T>
class BinaryTree
{
public:
    BinaryTree(){ root = NULL;
    }

    //复制构造函数
    BinaryTree(const BinaryTree<T> &t);
    ~BinaryTree(){};
    bool IsEmpty() const{ return root == NULL };
    bool Root(T& x)const;//获取根节点值
    void MakeTree(const T& element, BinaryTree<T>& left, BinaryTree<T>& right);//创建二叉树
    void BreakTree(T& element, BinaryTree<T> &left, BinaryTree<T> &right);//分拆二叉树
    void PreOrder(void (*Visit)(BinaryTreeNode<T> *u))//前序遍历
    {
        PreOrder(Visit, root);
    }
    void InOrder(void(*Visit)(BinaryTreeNode<T> *u))const//中序遍历
    {
        InOrder(Visit, root);
    }
    void PostOrder(void(*Visit)(BinaryTreeNode<T> *u))const//后序遍历
    {
        PostOrder(Visit, root);
    }

    BinaryTreeNode<T>* CopyTree(const BinaryTreeNode<T>* t);//复制树

    void LevelOrder(void(*Visit)(BinaryTreeNode<T> *u))const;//层序遍历
　　　　//各种遍历输出
    void PreOutput()const;
    void InOutput()const;
    void PostOutput()const;
    void LevelOutput()const;
    void Delete();
    int Height()const//获取树的高度
    {
        return Height(root);
    }

    int Size();//树的节点数
private:
    BinaryTreeNode<T> *root;//根节点
    void PreOrder(void (*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t);
    void InOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t)const;
    void PostOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t)const;
    int Height(BinaryTreeNode<T> *t)const;
    

    static void output(BinaryTreeNode<T> *t)
    {
        std::cout << t->data << ' ';
    }

    static void freeNode(BinaryTreeNode<T> *t)
    {
        delete t;
        t = NULL;
    }
    
    static void ctsize(BinaryTreeNode<T> *t)
    {
        ++count;
    }

};

template<class T>
BinaryTreeNode<T>* BinaryTree<T>::CopyTree(const BinaryTreeNode<T>* t)
{
    if (t)
    {
        BinaryTreeNode<T>* lchild = CopyTree(t->LeftChild);
        BinaryTreeNode<T>* rchild = CopyTree(t->RightChild);
        root = new BinaryTreeNode<T>(t->data, lchild, rchild);
    }

    return root;
}

template<class T>
BinaryTree<T>::BinaryTree(const BinaryTree<T> &t)
{
    root = CopyTree(t.root);
}



template<class T>
int BinaryTree<T>::Size()
{
    count = 0;
    PreOrder(ctsize);
    return count;
}


template<class T>
int BinaryTree<T>::Height(BinaryTreeNode<T> *t)const
{
    if (!t)
    {
        return 0;
    }
    
    int ll = Height(t->LeftChild);
    int lr = Height(t->RightChild);

    if (ll > lr)
    {
        return ++ll;
    }
    else
        return ++lr;
}

template<class T>
bool BinaryTree<T>::Root(T& x) const
{
    if (root)
    {
        x = root->data;
        return true;
    }
    return false;
}

//当left和right以及this二叉树有重复时，利用拷贝构造函数复制一部分，以免左右子树指向同一个而引发错误
template<class T>
void BinaryTree<T>::MakeTree(const T& element, BinaryTree<T>& left, BinaryTree<T>& right)
{
    if (&left==&right&&this==&left)
    {
        BinaryTree<T> newTree = right;
        BinaryTree<T> newTree2 = left;
        root = new BinaryTreeNode<T>(element, newTree2.root, newTree.root);
    }
    else if (&left==&right)
    {
        BinaryTree<T> newTree = right;
        root = new BinaryTreeNode<T>(element, left.root, newTree.root);
    }
    else if (this==&left||this==&right)
    {
        BinaryTree<T> newTree = *this;
        root = new BinaryTreeNode<T>(element, left.root, newTree.root);
    }
    else
    root = new BinaryTreeNode<T>(element, left.root, right.root);

    left.root = right.root = NULL;
}

template<class T>
void BinaryTree<T>::BreakTree(T& element, BinaryTree<T> &left, BinaryTree<T> &right)
{
    if (root==NULL)
    {
        std::cerr << "树为空，不能拆分" << std::endl;
        return;
    }

    BinaryTree<T> newTree = *this;
    element = newTree.root->data;
    left.root = newTree.root->LeftChild;
    right.root = newTree.root->RightChild;

    delete root;
    root = NULL;
}

template<class T>
void BinaryTree<T>::PreOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t)
{
    if (t)
    {
        Visit(t);
        PreOrder(Visit, t->LeftChild);
        PreOrder(Visit, t->RightChild);
    }
}

template<class T>
void BinaryTree<T>::InOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t)const
{
    if (t)
    {
        InOrder(Visit, t->LeftChild);
        Visit(t);
        InOrder(Visit, t->RightChild);
    }
}

template<class T>
void BinaryTree<T>::PostOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t)const
{
    if (t)
    {
        PostOrder(Visit, t->LeftChild);
        PostOrder(Visit, t->RightChild);
        Visit(t);
    }
}

template<class T>
void BinaryTree<T>::LevelOrder(void(*Visit)(BinaryTreeNode<T> *u))const
{
    LinkedQueue<T> Q;
    BinaryTreeNode<T> *t = root;
    while (t)
    {
        Visit(t);
        if (t->LeftChild)
        {
            Q.Add(t->LeftChild);
        }
        if (t->RightChild)
        {
            Q.Add(t->RightChild);
        }

        if (Q.IsEmpty())
        {
            return;
        }
        Q.Delete(t);
    }    
}

template<class T>
void BinaryTree<T>::PreOutput()const
{
    PreOrder(output, root);
}

template<class T>
void BinaryTree<T>::InOutput()const
{
    InOrder(output, root);
}

template<class T>
void BinaryTree<T>::PostOutput()const
{
    PostOrder(output, root);
}

template<class T>
void BinaryTree<T>::LevelOutput()const
{
    LevelOutput(output, root);
}

template<class T>
void BinaryTree<T>::Delete()
{
    PostOrder(freeNode, root);
    root = NULL;
}

 几个操作的解释：

前三种遍历可以用递归完成，层次调用则利用队列

删除：

要删除一棵二叉树，需要删除其所有节点。可以通过后序遍历在访问一个节点时，把其删除。也就是说先删除左子树，然后右子树，最后删除根。

计算高度：

通过进行后序遍历，可以得到二叉树的高度。首先得到左子树的高度 h l，然后得到右子树的高度h r。此时，树的高度为：m a x { h l， hr} + 1


简单测试：

#include<iostream>
#include "binaryTree.h"

int countx = 0;
BinaryTree<int> a, x, y, z;

template<class T>
void ct(BinaryTreeNode<T> *t)
{
    ++countx;
}

void main(void)
{
    y.MakeTree(1, a, a);
    z.MakeTree(2, y, y);
    x.MakeTree(3, y, z);
    y.MakeTree(4, x, a);
    y.PreOrder(ct);
    
    std::cout << countx << std::endl;
    std::cout << y.Height() << std::endl;
    std::cout << y.Size() << std::endl;
    y.Delete();
    std::cout << y.Height() << std::endl;
    std::cout << y.Size() << std::endl;    
}