二叉树（使用C++模板）

CBinTree.hpp

#include <iostream>
#include <queue>
#include <stack>

template <typename T>
class BinTree
{
private:
    // 树节点
    typedef struct BinTreeNode
    {
        T data;
        struct BinTreeNode* left;
        struct BinTreeNode* right;
    }Node;
    
    // 树
    typedef struct
    {
        T stop;
        Node* root;
    }Tree;

private:
    Tree m_Tree;

public:
    // 初始化树
    BinTree(T stop);
    BinTree();
    ~BinTree();
    
    // 创建树
    void Create(T* array, unsigned int nLength);
    
    // 先序遍历
    void Preorder();
    
    // 中序遍历
    void Inorder();
    
    // 后序遍历
    void Postorder();
    
    // 层次遍历
    void Levelorder();
    
    // 先序非递归遍历
    void preOrder();
    
    // 中序非递归遍历
    void inOrder();
    
    // 后序非递归遍历
    void postOrder();
    
    // 返回节点个数
    int Size();
    
    // 返回树的高度（层次）
    int Height();
    
    // 查找并修改
    bool Modify(T src, T dst);
    
    // 判断是否为空树
    bool isEmpty();
    
    // 拷贝树
    bool Copy(BinTree& tree);
    
    // 清除树
    void Clear();

    // 返回树根
    void* GetRoot();
public:
    BinTree& operator=(BinTree& tree);
private:
    void Create(Node* &node, T* &array, unsigned int nLength);
    void Preorder(Node* node);
    void Inorder(Node* node);
    void Postorder(Node* node);
    void Levelorder(Node* node);
    void preOrder(Node* node);
    void inOrder(Node* node);
    void postOrder(Node* node);
    int Size(Node* node);
    int Height(Node* node);
    bool Modify(Node* node, T src, T dst);
    bool Copy(Node* &dst, Node* src);
    void Clear(Node* &node);
};

template<typename T>
inline BinTree<T>::BinTree()
{
    memset(&m_Tree, 0, sizeof(m_Tree));
}

template<typename T>
inline BinTree<T>::~BinTree()
{
    Clear();
}

/* 初始化树 */
template<typename T>
inline BinTree<T>::BinTree(T stop)
{
    m_Tree.root = nullptr;
    m_Tree.stop = stop;
}

/* 创建树 */
template<typename T>
inline void BinTree<T>::Create(T* array, unsigned int nLength)
{
    Create(m_Tree.root, array, nLength);
}

template<typename T>
inline void BinTree<T>::Create(Node* &node, T* &array, unsigned int nLength)
{
    static int nLen = nLength;
    static int nCnt = 0;
    nCnt++;

    if (*array == m_Tree.stop) node = nullptr;
    else
    {
        node = new Node;
        if (nullptr == node) return;
        node->data = *array;

        if (nCnt == nLen) return;

        Create(node->left, ++array, nLength);
        Create(node->right, ++array, nLength);
    }
}

/* 先序遍历树 */
template<typename T>
inline void BinTree<T>::Preorder()
{
    Preorder(m_Tree.root);
}

template<typename T>
inline void BinTree<T>::Preorder(Node * node)
{
    if (nullptr == node) return;

    std::cout << node->data;
    if (nullptr != node->left) Preorder(node->left);
    if (nullptr != node->right) Preorder(node->right);
}

/* 中序遍历树 */
template<typename T>
inline void BinTree<T>::Inorder()
{
    Inorder(m_Tree.root);
}

template<typename T>
inline void BinTree<T>::Inorder(Node * node)
{
    if (nullptr == node) return;

    if (nullptr != node->left) Inorder(node->left);
    std::cout << node->data;
    if (nullptr != node->right) Inorder(node->right);
}

/* 后序遍历树 */
template<typename T>
inline void BinTree<T>::Postorder()
{
    Postorder(m_Tree.root);
}

template<typename T>
inline void BinTree<T>::Postorder(Node * node)
{
    if (nullptr == node) return;

    if (nullptr != node->left) Postorder(node->left);
    if (nullptr != node->right) Postorder(node->right);
    std::cout << node->data;
}

/* 层次遍历树 */
template<typename T>
inline void BinTree<T>::Levelorder()
{
    Levelorder(m_Tree.root);
}

template<typename T>
inline void BinTree<T>::Levelorder(Node * node)
{
    if (nullptr == node) return;

    std::queue<Node*> Q;
    Q.push(node);

    Node* p = nullptr;
    while (!Q.empty())
    {
        p = Q.front();
        std::cout << p->data;
        Q.pop();

        if (nullptr != p->left) Q.push(p->left);
        if (nullptr != p->right) Q.push(p->right);
    }

    p = nullptr;
}

/* 先序非递归遍历树 */
template<typename T>
inline void BinTree<T>::preOrder()
{
    preOrder(m_Tree.root);
}

template<typename T>
inline void BinTree<T>::preOrder(Node * node)
{
    if (nullptr == node) return;

    std::stack<Node*> S;
    S.push(node);

    Node* p = nullptr;
    while (!S.empty())
    {
        p = S.top();
        std::cout << p->data;
        S.pop();

        if (nullptr != p->right) S.push(p->right);
        if (nullptr != p->left) S.push(p->left);
    }

    p = nullptr;
}

/* 中序非递归遍历树 */
template<typename T>
inline void BinTree<T>::inOrder()
{
    inOrder(m_Tree.root);
}

template<typename T>
inline void BinTree<T>::inOrder(Node * node)
{
    if (nullptr == node) return;

    std::stack<Node*> S;
    S.push(node);

    Node* p = node;
    Node* q = nullptr;
    while (!S.empty())
    {
        while (nullptr != p && nullptr != p->left)
        {
            S.push(p->left);
            p = p->left;
        }

        q = S.top();
        std::cout << q->data;
        S.pop();

        if (nullptr != q->right)
        {
            S.push(q->right);
            p = q->right;
        }
    }

    p = q = nullptr;
}

/* 后序非递归遍历树 */
template<typename T>
inline void BinTree<T>::postOrder()
{
    postOrder(m_Tree.root);
}

template<typename T>
inline void BinTree<T>::postOrder(Node * node)
{
    if (nullptr == node) return;

    typedef struct
    {
        Node* ptr;
        bool  bFlag;
    }FlagNode;
    FlagNode fn = { 0 };

    std::stack<FlagNode> S;

    Node* p = node;
    bool  bSign = true;
    do
    {
        while (nullptr != p)
        {
            fn.ptr = p;
            fn.bFlag = false;
            S.push(fn);
            p = p->left;
        }

        bSign = true;

        while (bSign && !S.empty())
        {
            fn = S.top();
            S.pop();

            // bFlag = false 表示节点还没有判断右节点
            // bFlag = true  表示节点已经判断完右节点
            if (false == fn.bFlag)       
            {
                fn.bFlag = true;
                S.push(fn);
                p = fn.ptr->right;
                bSign = false;
            }
            else
            {
                std::cout << fn.ptr->data;
            }
        }
    } while (!S.empty());

    p = nullptr;
}

/* 返回节点个数 */
template<typename T>
inline int BinTree<T>::Size()
{
    return Size(m_Tree.root);
}

template<typename T>
inline int BinTree<T>::Size(Node * node)
{
    if (nullptr == node) return 0;

    return Size(node->left) + Size(node->right) + 1;
}

/* 返回树的高度（层次） */
template<typename T>
inline int BinTree<T>::Height()
{
    return Height(m_Tree.root);
}

template<typename T>
inline int BinTree<T>::Height(Node * node)
{
    if (nullptr == node) return 0;

    int left = 0;
    int right = 0;

    left = Height(node->left);
    right = Height(node->right);
    if (left > right) return left + 1;
    else
    {
        return right + 1;
    }
}

/* 查找并修改 */
template<typename T>
inline bool BinTree<T>::Modify(T src, T dst)
{
    return Modify(m_Tree.root, src, dst);
}

template<typename T>
inline bool BinTree<T>::Modify(Node * node, T src, T dst)
{
    if (nullptr == node) return false;

    if (src == node->data)
    {
        node->data = dst;
        return true;
    }

    bool bRet = true;

    bRet = Modify(node->left, src, dst);
    if (bRet) return true;
    else
    {
        bRet = Modify(node->right, src, dst);
    }

    return bRet;
}

/* 判断是否为空树 */
template<typename T>
inline bool BinTree<T>::isEmpty()
{
    if (nullptr == m_Tree.root) return true;

    return false;
}

/* 拷贝树 */
template<typename T>
inline bool BinTree<T>::Copy(BinTree& tree)
{
    if (tree.isEmpty()) return false;
    if (!isEmpty()) Clear(m_Tree.root);

    return Copy(m_Tree.root, (Node*)tree.GetRoot());
}

template<typename T>
inline bool BinTree<T>::Copy(Node* &dst, Node* src)
{
    if (nullptr == src)
    {
        dst = nullptr;
        return true;
    }

    dst = new Node;
    if (nullptr == dst) return false;
    dst->data = src->data;

    bool bRet = true;
    bRet = Copy(dst->left, src->left);
    if (!bRet) return false;
    else
    {
        bRet = Copy(dst->right, src->right);
    }
    return bRet;
}

/* 清除树 */
template<typename T>
inline void BinTree<T>::Clear()
{
    if (!isEmpty()) Clear(m_Tree.root);
}

template<typename T>
inline void BinTree<T>::Clear(Node* &node)
{
    if (nullptr == node) return;

    Clear(node->left);
    Clear(node->right);
    delete node;

    node = nullptr;
}

/* 返回树根 */
template<typename T>
inline void * BinTree<T>::GetRoot()
{
    return m_Tree.root;
}

template<typename T>
inline BinTree<T> & BinTree<T>::operator=(BinTree & tree)
{
    Copy(tree);

    return *this;
}

main.cpp

#include "CBinTree.hpp"

int main()
{
    char str[] = "ABC##DE##F##G#H##";
    int nStrLen = strlen(str);

    BinTree<char> CharTree('#');
    CharTree.Create(str, nStrLen);
    CharTree.Preorder();
    puts("");

    BinTree<char> CharCopy;
    CharCopy = CharTree;
    //CharCopy.Copy(CharTree);
    CharCopy.Preorder();
    puts("");

//////////////////////////////////////////////////////////////////
    int array[] = { 1,2,3,9,9,4,5,9,9,6,9,9,7,9,8,9,9 };
    int nIntLen = sizeof(array) / sizeof(int);

    BinTree<int> IntTree(9);
    IntTree.Create(array, nIntLen);
    IntTree.Preorder();
    puts("");

    BinTree<int> IntCopy;
    IntCopy = IntTree;
    //IntCopy.Copy(IntTree);
    IntCopy.Preorder();
    puts("");

    system("pause");
    return 0;
}