简单链式二叉树（C++模版技术实现）

下面代码仅供本人复习数据结构所用，实用性N低，各位飘过吧~~哈哈:>

//
// C++ 模版技术实现简单二叉树. 
//
 
#include <cstdlib>
#include <cstring>
#include <iostream>
 
// 二叉树类模版前置声明
template <typename T> class BinaryTree; 
 
//
// 二叉树节点类模版. 
//
template <typename T>
class Node
{
    friend class BinaryTree<T>;
private:
    T _data;
    Node<T> *_pLeftChild, *_pRightChild;
     
public:
    Node(const T &data)
        : _data(data)
        , _pLeftChild(NULL)
        , _pRightChild(NULL)
    { NULL; }
};
 
//
// 二叉树类模版 
//
template <typename T> 
class BinaryTree
{
private:
    Node<T> *_pRoot;
     
private:
    void _create(Node<T> **ppRoot, T **ppArray, int *piSize, const T &delim);
    void _clear(Node<T> *pRoot);
    void _preOrder(Node<T> *pRoot) const;
    void _inOrder(Node<T> *pRoot) const;
    void _postOrder(Node<T> *pRoot) const; 
    size_t _height(Node<T> *pRoot) const; 
    size_t _count(Node<T> *pRoot) const; 
     
public:
    // 遍历类型. 
    enum TraversalType {
        PRE_ORDER,
        IN_ORDER,
        POST_ORDER  
    };
     
public:
    BinaryTree(T *array, int size, const T &delim);
    ~BinaryTree(void);
    void traversal(const TraversalType type) const;
    size_t getHeight(void) const;
    size_t getNumberOfNode(void) const;
};
 
//
// 创建二叉树.
// 这里基于前序遍历构造二叉树，输入的是二叉树的先序序列， 
// 但必须在其中加入虚节点以表示空指针的位置. 
// 例如： 
//             (A)
//           /    \
//        (B)     (C)
//       /   \   /   \
//     (D)   %  (E)  (F)
//    /  \     /  \  / \
//   %   %    %   % %   %
//
// 其中字母代表节点，% 代表虚节点，故上图先序序列为：ABD%%%CE%%F%%. 
//
// 参数 ppRoot 是指向根指针的指针，故修改 *ppRoot 就修改了实参（根指针）本身.
// 参数 ppArray 是指向存储先序序列数组地址的指针，我们也需要必要的修改.
// 参数 piSize 是指向表示数组大小的整型变量的指针，我们也需要修改它. 
// 参数 delim 是分隔符，用来指代虚节点，我们需要跳过虚节点。 
// 
template <typename T>
void BinaryTree<T>::_create(Node<T> **ppRoot, 
                            T **ppArray, 
                            int *piSize,
                            const T &delim)
{
    if (0 < *piSize && delim != **ppArray) 
    {
        *ppRoot = new Node<T>(**ppArray);
        _create(&((*ppRoot)->_pLeftChild), &(++*ppArray), &(--*piSize), delim);
        _create(&((*ppRoot)->_pRightChild), &(++*ppArray), &(--*piSize), delim);
    }
}
//
// 删除所有节点. 
//
template <typename T> 
void BinaryTree<T>::_clear(Node<T> *pRoot)
{
    if (NULL != pRoot)
    {
        _clear(pRoot->_pLeftChild);
        _clear(pRoot->_pRightChild);
        delete pRoot;
    }
}
 
//
// 前序遍历. 
//
template <typename T> 
void BinaryTree<T>::_preOrder(Node<T> *pRoot) const
{
    if (NULL != pRoot)
    {
        std::cout << pRoot->_data << " ";
        _preOrder(pRoot->_pLeftChild);
        _preOrder(pRoot->_pRightChild);
    }
}
 
//
// 中序遍历. 
//
template <typename T> 
void BinaryTree<T>::_inOrder(Node<T> *pRoot) const
{
    if (NULL != pRoot)
    {
        _inOrder(pRoot->_pLeftChild);
        std::cout << pRoot->_data << " ";
        _inOrder(pRoot->_pRightChild);
    }
}
 
//
// 后序遍历. 
//
template <typename T> 
void BinaryTree<T>::_postOrder(Node<T> *pRoot) const
{
    if (NULL != pRoot)
    {
        _postOrder(pRoot->_pLeftChild);
        _postOrder(pRoot->_pRightChild);
        std::cout << pRoot->_data << " ";
    }
}
 
//
// 通过后序遍历方式计算二叉树高度. 
//
template <typename T> 
size_t BinaryTree<T>::_height(Node<T> *pRoot) const
{
    static size_t height = 0, leftHeight = 0, rightHeight = 0;
     
    if (NULL != pRoot)
    {
        leftHeight = _height(pRoot->_pLeftChild);
        rightHeight = _height(pRoot->_pRightChild);
         
        height = (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;
    }
    else {
        height = 0;
    }
     
    return height;
}
 
//
// 通过前序遍历方式计算二叉树节点数. 
//
template <typename T> 
size_t BinaryTree<T>::_count(Node<T> *pRoot) const
{
    static size_t counter = 0;
     
    if (NULL != pRoot) {
        counter = _count(pRoot->_pLeftChild) + _count(pRoot->_pRightChild) + 1;
    }
    else {
        counter = 0;
    }
    return counter;
}
 
 
template <typename T> 
inline BinaryTree<T>::BinaryTree(T *array, int size, const T &delim)
{ 
    _create(&_pRoot, &array, &size, delim);
}
 
 
template <typename T> 
inline BinaryTree<T>::~BinaryTree(void)
{
    _clear(_pRoot);
}
 
//
// 根据控制标识选择遍历方式. 
// 
template <typename T> 
void BinaryTree<T>::traversal(const TraversalType type) const
{
    switch (type)
    {
        case PRE_ORDER  :   _preOrder(_pRoot);  break;
        case IN_ORDER   :   _inOrder(_pRoot);   break;  
        case POST_ORDER :   _postOrder(_pRoot); break;
    }
}
 
 
template <typename T> 
size_t BinaryTree<T>::getHeight(void) const
{
    return _height(_pRoot);
}
 
 
template <typename T> 
size_t BinaryTree<T>::getNumberOfNode(void) const
{
    return _count(_pRoot);
}
 
//
// 测试二叉树. 
//
int main(void)
{
    const size_t MAX_SIZE = 100;
    char szPreOrder[MAX_SIZE] = {'\0'};
     
    std::cout << "请输入二叉树节点数据前序序列：" << std::endl; 
    while (!std::cin.getline(szPreOrder, MAX_SIZE))
    {
        std::cout << "输入错误. " << std::endl;
        std::cout << "重新输入: ";
        std::cin.clear();
        std::cin.sync();    
    }
     
    BinaryTree<char> binTree(szPreOrder, strlen(szPreOrder), ' ');
     
    //
    // 遍历二叉树. 
    //
    std::cout << "前序遍历：";
    binTree.traversal(BinaryTree<char>::PRE_ORDER);
    std::cout << std::endl << "中序遍历：";
    binTree.traversal(BinaryTree<char>::IN_ORDER);
    std::cout << std::endl << "中序遍历：";
    binTree.traversal(BinaryTree<char>::POST_ORDER);
    std::cout << std::endl;
     
    std::cout << "树高：" << binTree.getHeight() << std::endl; 
    std::cout << "节点：" << binTree.getNumberOfNode() << std::endl; 
     
    return EXIT_SUCCESS;
}