求二叉树叶子节点的个数/求二叉树第k层的节点个数。

#include <iostream>

using namespace std;

template<class T>
struct BinaryTreeNode
{
    BinaryTreeNode(const T& data)
        :_data(data)
        ,_Left(NULL)
        ,_Right(NULL)
    {}  

    T _data;
    BinaryTreeNode<T>* _Left;
    BinaryTreeNode<T>* _Right;  
};

template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;
public:
    BinaryTree()        
        :_root(NULL)
    {}

    //构造函数
    BinaryTree(const T array[], size_t size, const T& invalid)  //前序遍历创建二叉树
    {
        size_t index = 0;
        _CreateTree(_root, array, size ,invalid, index);
    }

    //拷贝构造函数
    BinaryTree(const BinaryTree<T>& t)
    {
        _root = _CopyBinaryTree(t._root);
    }

    //赋值运算符的重载
    BinaryTree<T>& operator=(const BinaryTree<T>& t)
    {
        if (this != &t)
        {
            _Destroy(_root);
            _root = _CopyBinaryTree(t._root);
        }

        return *this;
    }

    //先序遍历
    void PreOrder()
    {
        cout<<"PreOrder: "<<endl;
        _PreOrder(_root);
        cout<<endl;
    }

    //求二叉树叶子结点的个数
    size_t GetLeafNode()
    {
        return _GetLeafNode(_root);
    }

    //求二叉树第K层的结点个数
    size_t GetKLevelNode(size_t k)
    {
        return _GetKLevelNode(_root, k);
    }

    //获取二叉树的高度
    size_t GetHeight()
    {
        return _GetHeight(_root);
    }

    ~BinaryTree()      //析构函数
    {
        _Destroy(_root);
    }

private:
    void _CreateTree(Node *& root, const T array[], size_t size , const T& invalid, size_t& index)
    {
        if ((index < size) && (array[index] != invalid))
        {
            //1.创建根节点
            root = new Node(array[index]);
            //2.创建根节点的左子树
            _CreateTree(root->_Left, array, size, invalid, ++index);
            //3.创建根节点的右子树
            _CreateTree(root->_Right, array, size, invalid, ++index);
        }
    }

    Node* _CopyBinaryTree(Node* root)
    {
        Node* NewNode = NULL;

        if (root != NULL)
        {
            NewNode = new Node(root->_data);
            NewNode->_Left = _CopyBinaryTree(root->_Left);
            NewNode->_Right = _CopyBinaryTree(root->_Right);
        }

        return NewNode;
    }

    void _Destroy(Node*& root)
    {
        if (root != NULL)
        {
            _Destroy(root->_Left);
            _Destroy(root->_Right);
            delete root;
            root = NULL;
        }
    }

    void _PreOrder(Node* root)  //先序遍历：根节点->左子树->右子树
    {
        if (root == NULL)
            return ;

        cout<<root->_data<<" ";
        //遍历左子树
        _PreOrder(root->_Left);
        //遍历右子树
        _PreOrder(root->_Right);
    }

    //获取叶子结点的个数
    size_t _GetLeafNode(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }

        if (root->_Left == NULL && root->_Right == NULL)
        {
            return 1;
        }

        return (_GetLeafNode(root->_Left) + _GetLeafNode(root->_Right));        
    }

    //获取第K层结点的个数
    size_t _GetKLevelNode(Node* root, size_t k)
    {
        if (root == NULL || k < 1 || k > _GetHeight(root))
            return 0;
        if (k == 1)
            return 1;

        size_t leftcount = _GetKLevelNode(root->_Left, k-1);
        size_t rightcount = _GetKLevelNode(root->_Right, k-1);

        return (leftcount + rightcount);
    }

    //获取二叉树的高度
    size_t _GetHeight(Node* root)
    {
        if (root == NULL)
            return 0;
        if (root->_Left == NULL && root->_Right == NULL)
            return 1;

        size_t leftheight = _GetHeight(root->_Left);
        size_t rightheight = _GetHeight(root->_Right);

        return (leftheight > rightheight)?(leftheight+1):(rightheight+1);       
    }

private:
    BinaryTreeNode<T>* _root;
};


int main()
{
    const char* ptr = "124###35##6";
    BinaryTree<char> t(ptr, strlen(ptr), '#');
    BinaryTree<char> t1(t);
    BinaryTree<char> t2;
    t2 = t;

    cout << t.GetLeafNode() << endl;
    cout << t.GetKLevelNode(2) << endl;

    return 0;
}