二叉树的基本操作

唯一需要注意的就是里面几种遍历的非递归实现，借助了队列和栈来进行实现。
下面是完整的代码：

#pragma once

#include<iostream>
#include<stack>
#include<queue>
using namespace std;


//孩子表示法
template<class T>
struct BinaryTreeNode
{
    BinaryTreeNode(const T& value)
    :_value(value)
    , _pLeft(NULL)
    , _pRight(NULL)
    {};

    T _value;
    BinaryTreeNode<T>* _pLeft;
    BinaryTreeNode<T>* _pRight;
};

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

    BinaryTree(const T array[], size_t size, const T& invalid)
    {
        size_t index = 0;//
        _CreateBinaryTree(_pRoot, array, size, index, invalid);
    }
    //下面使用到了&index,但是不能对一个常量进行引用，所以要把index定义为一个变量
    BinaryTree(const BinaryTree<T>& bt)
    {
        _pRoot = CopyBinaryTree(bt._pRoot);
    }

    BinaryTree<T>& operator=(const BinaryTree<T>& bt)
    {
        if (this != &bt)
        {
            _DestroyBinaryTree(_pRoot);

            _pRoot = CopyBirnaryTree(bt._pRoot);
        }

        return *this;
    }
    ~BinaryTree()
    {
        _DestroyBinaryTree(_pRoot);
    }
    void PreOrder()
    {
        cout << "PreOrder:" << endl;
        _PreOrder(_pRoot);
        cout << endl;
    }

    void PostOrder()
    {
        cout << "PostOrder:" << endl;
        _PostOrder(_pRoot);
        cout << endl;
    }

    void MidOrder()
    {
        cout << "MidOrder:" << endl;
        _MidOrder(_pRoot);
        cout << endl;
    }

    Node* Find(const T& value)
    {
        return _Find()
    }

    void PostOrder_Nor()//非递归实现后序
    {
        cout << "PostOrder_Nor:" << endl;
        if (NULL == _pRoot)
            return;
        stack<Node*> s;
        Node* pCur = _pRoot;
        Node* pPre = NULL;
        while (pCur || !s.empty())
        {
            while (pCur)
            {
                s.push(pCur);
                pCur = pCur->_pLeft;
            }
            Node* pTop = s.top();
            if (NULL == pTop->_pRight || pTop->_pRight == pPre)
            {
                cout << pTop->_value << " ";
                pPre = pTop;
                s.pop();
            }
            else
                pCur = pTop->_pRight;
        }

    }

    void MidOrder_Nor()//非递归实现中序
    {
        cout << "MidOrder_Nor:" << endl;
        if (NULL == _pRoot)
            return;
        stack<Node*> s;
        Node *pCur = _pRoot;
        while (!s.empty() || pCur)
        {
            while (pCur)
            {
                s.push(pCur);
                pCur = pCur->_pLeft;
            }
            if (NULL == pCur && !s.empty())
            {
                pCur = s.top();
                cout << pCur->_value << " ";
                s.pop();
                pCur = pCur->_pRight;
            }
        }
    }

    void PreOrder_Nor()//非递归实现前序
    {
        if (NULL == _pRoot)
            return;
        stack<Node*> s;
        s.push(_pRoot);
        while (!s.empty())
        {
            Node* pTop = s.top();
            cout << pTop->_value << " ";
            s.pop();
            if (pTop->_pRight)
                s.push(pTop->_pRight);
            if (pTop->_pLeft)
                s.push(pTop->_pLeft);
        }
    }

    bool IsComPleteBinaryTree()//利用层序遍历判断是否为完全二叉树
    {
        if (NULL == _pRoot)
            return true;
        bool flag = false;
        queue<Node*> q;
        Node* pCur = _pRoot;
        q.push(_pRoot);
        while (!q.empty())
        {
            Node* pCur = q.front();
            if (flag)
            {
                if (pCur->_pLeft || pCur->_pRight)
                    return false;
            }
            else
            {
                if (pCur->_pLeft&&pCur->_pRight)
                {
                    q.push(pCur->_pLeft);
                    q.push(pCur->_pRight);
                }
                else if (pCur->_pLeft)
                {
                    q.push(pCur->_pLeft);
                    flag = true;
                }
                else if (pCur->_pRight)
                {
                    q.push(pCur->_pRight);
                    flag = false;
                }
                else
                    flag = true;
            }
            q.pop();
        }
        return true;
    }




private:
    void _CreateBinaryTree(Node* &pRoot, const T array[],size_t size, size_t& index,const T& invalid)
    {
        if (index < size && invalid != array[index])//注意条件的判断次序
        {
            //创建根节点
            pRoot = new Node(array[index]);

            //创建左子数
            _CreateBinaryTree(pRoot->_pLeft, array, size, ++index,invalid);//如果用index+1，初始的index并没有发生变化

            //创建右子数
            _CreateBinaryTree(pRoot->_pRight, array, size, ++index, invalid);

        }
    }

    Node* CopyBirnaryTree(Node* pRoot)
    {
        Node* pNewNode = NULL;
        //拷贝根节点
        if (pRoot)
        {
            pNewNode = new Node(pRoot->_value);

            //拷贝左子树
            pNewNode->_pLeft = CopyBirnaryTree(pRoot->_pLeft);

            //拷贝右子树 
            pNewNode->_pRight = CopyBirnaryTree(pRoot->_pRight);
        }
        return pNewNode;
    }




    void _DestroyBinaryTree(Node* &pRoot)
    {
        if (pRoot)
        {
            _DestroyBinaryTree(pRoot->_pLeft);
            _DestroyBinaryTree(pRoot->_pRight);
            delete pRoot;
            pRoot = NULL;
        }
    }
    void _PreOrder(Node* pRoot)
    {
        if (pRoot)
        {
            cout << pRoot->_value << " ";

            _PreOrder(pRoot->_pLeft);
            _PreOrder(pRoot->_pRight);
        }
    }

    void _PostOrder(Node* pRoot)
    {
        if (pRoot)
        {
            _PreOrder(pRoot->_pLeft);       
            _PreOrder(pRoot->_pRight);
            cout << _pRoot->_value << " ";
        }
    }

    void _MidOrder(Node* pRoot)
    {
        if (pRoot)
        {
            _PreOrder(pRoot->_pLeft);
            cout << _pRoot->_value << " ";
            _PreOrder(pRoot->_pRight);

        }
    }




private:
    Node* _pRoot;//根节点
};

int main()
{
    char* ptr = "124###35##6";
    BinaryTree<char> bt(ptr, strlen(ptr), '#');
    //BinaryTree<char> bt1(bt);

    //bt.PostOrder();
    bt.MidOrder_Nor();
    /*bt.MidOrder();
    BinaryTree<char> bt2;
    bt2 = bt;
    bt2.PreOrder();
    bt2.PostOrder_Nor();
    bt2.IsComPleteBinaryTree();*/


    return 0;
}