二叉树的完整操作

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

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

    T _data;
    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;
        _CreateTree(_pRoot, array, size, index, invalid);
    }

    //拷贝二叉树
    BinaryTree(const BinaryTree<T>& t)
    {
        _pRoot = _CopyBinaryTree(t._pRoot);
    }

    //二叉树的赋值函数
    BinaryTree<T>& operator=(const BinaryTree<T>& t)
    {
        if(this != NULL)
        {
            _DestroyTree(_pRoot);
            _pRoot = _CopyBinaryTree(t._pRoot);

            return *this;
        }

    }

    // 递归前序遍历：访问根结点-->左子树-->右子树
    void PreOrder()
    {
        cout<<"递归前序遍历：";
        _PreOrder(_pRoot);
        cout<<endl<<endl;
    }

    // 非递归前序遍历：访问根结点-->左子树-->右子树
    void PreOrder_Nor()
    {
        cout<<"非递归前序遍历：";
        if(_pRoot == NULL)//空树
            return;

        stack<Node*> s;
        s.push(_pRoot); //根节点入栈

        while(!s.empty())
        {
            Node* pCur = s.top(); //取当前节点
            cout<<pCur->_data<<" "; //访问当前节点
            s.pop(); //出栈

            if(pCur->_pRight)
                s.push(pCur->_pRight); //右子树先入栈

            if(pCur->_pLeft)
                s.push(pCur->_pLeft); //左子树再入栈
        }

        cout<<endl<<endl;
    }

    // 递归中序遍历：访问左子树-->根结点-->右子树 
    void InOrder()
    {
        cout<<"中序遍历：";
        _InOrder(_pRoot);
        cout<<endl<<endl;
    }

    // 非递归中序遍历：访问左子树-->根结点-->右子树 
    void InOrder_Nor()
    {
        cout<<"非递归中序遍历：";
        if(_pRoot == NULL)
            return;  //空树

        Node* pCur = _pRoot;
        stack<Node*> s;

        while(!s.empty() || pCur)
        {
            //找最左边节点，并保存该路径上的所有节点
            while(pCur)
            {
                s.push(pCur);
                pCur = pCur->_pLeft;
            }

            pCur = s.top(); //取栈顶
            cout<<pCur->_data<<" "; //访问
            s.pop(); //出栈

            pCur = pCur->_pRight;
        }

        cout<<endl<<endl;
    }

    // 后序遍历：访问左子树-->右子树-->根节点
    void PostOrder()
    {
        cout<<"后序遍历：";
        _PostOrder(_pRoot);
        cout<<endl<<endl;
    }

    // 后续遍历的非递归版本：访问左子树-->右子树-->根节点
    void PostOrder_Nor()
    {
        cout<<"非递归中序遍历：";
        if(_pRoot == NULL)
            return;

        Node* pCur = _pRoot;
        Node* prev = NULL;
        stack<Node*> s;

        while(!s.empty() || pCur)
        {
            //找最左边节点并保存路径上所有节点
            while(pCur)
            {
                s.push(pCur);
                pCur = pCur->_pLeft;
            }

            pCur = s.top(); //取栈顶
            if(pCur->_pRight == NULL || prev == pCur->_pRight)
            {
                cout<<pCur->_data<<" "; //访问
                prev = pCur; //标记
                s.pop();
                pCur = NULL;
            }

            else
            {
                pCur = pCur->_pRight;
            }
        }

        cout<<endl<<endl;
    }

    // 层序遍历
    void LevelOrder()
    {
        cout<<"层序遍历：";
        _LevelOrder(_pRoot);
        cout<<endl<<endl;
    }

    ~BinaryTree()
    {
        _DestroyTree(_pRoot);
        _pRoot = NULL;
    }

    //找到节点的双亲节点
    Node* GetParent(Node* x)
    {
        return _GetParent(_pRoot,x);
    }

    //找到结点的左孩子
    Node* GetLeftChild(Node* pCur)
    {
        return pCur->_pLeft;
    }

    //找到结点的右孩子
    Node* GetRightChild(Node* pCur)
    {
        return pCur->_pRight;
    }

    //在二叉树中查找某个节点
    Node* Find(const T& value)
    {
        return _Find(_pRoot, value);
    }

    //二叉树的高度
    size_t Height()
    {
        return _Height(_pRoot);
    }

    //叶子结点的个数
    size_t GetLeefNode()
    {
        return _GetLeefNode(_pRoot);
    }

    //第K层有几个节点
    size_t GetKLevelNode(size_t k)
    {
        return _GetKLevelNode(_pRoot, k);
    }


    // 求二叉树的镜像：非递归
    void GetBinaryMirror_Nor()
    {
        queue<Node *> q;  
        Node *pointer = _pRoot;//当前处理的节点为根节点  
        while (pointer)  
        {  
            swap(pointer->_pLeft, pointer->_pRight);//交换当前处理节点的孩子  
            if (pointer->_pLeft)//左孩子不为空  
                q.push(pointer->_pLeft); 

            if (pointer->_pRight)//右孩子不为空  
                q.push(pointer->_pRight); 

            if (!q.empty())  
            {  
                pointer = q.front();  
                q.pop();  
            }  
            else  
            {  
                break;  
            }  
        } 
    }

    // 求二叉树的镜像：递归版本
    void GetBinaryMirror()
    {
        return _GetBinaryMirror(_pRoot);
    }

    // 利用层序遍历来处理--> 关键：找第一个度不为2的结点-->后续结点
    // 如果有孩子则不是完全二叉树
    // 否则：是
    bool IsCompleteBinaryTree()
    {
        if(_pRoot == NULL)
            return true;
        Node* pCur = NULL;
        queue<Node*> q;
        q.push(_pRoot);

        int flag = false;

        while(!q.empty())
        {
            pCur = q.front();
            q.pop();

            if(flag == true)
            {
                if(pCur->_pLeft != NULL || pCur->_pRight != NULL)
                    return false;
                return true;
            }
            else
            {
                if(pCur->_pLeft != NULL && pCur->_pRight != NULL)  
                {  
                    q.push(pCur->_pLeft);  
                    q.push(pCur->_pRight);  
                }
                else if(pCur->_pRight!= NULL)
                {
                    return false;
                }
                else if(pCur->_pLeft != NULL)
                {
                    q.push(pCur->_pLeft);
                    flag = true;
                }
                else
                {
                    flag = true;
                }
            }
        }
        return false;
    }



    // 求二叉树中两个节点的最近公共祖先节点
    Node* GetLastCommonParent(Node* Node1, Node* Node2)
    {
        return _GetLastCommonParent(_pRoot, Node1, Node2);
    }



    // 由前序遍历序列和中序遍历序列重建二叉树
    Node* RebuildBinaryTree(char* PreOrder, char* InOrder, int length)
    {
        //int len1 = sizeof(PreOrder/PreOrder[0]);
        //int len2 = sizeof(InOrder/InOrder[0]);

        //if(len1 != len2)
            //return NULL;

        if(PreOrder == NULL || InOrder == NULL || length < 0)
            return NULL;

        // 前序遍历的第一个数据就是根节点数据 
        Node* _pRoot = new BinaryTreeNode<char>(PreOrder[0]);



        // 查找根节点在中序遍历中的位置,中序遍历中,根节点左边为左子树,右边为右子树  
        int rootPositionInOrder = -1;  
        for(int i = 0; i < length; i++)  
        {
            if(InOrder[i] == _pRoot->_data)  
            {  
                rootPositionInOrder = i;  
                break;  
            }
        }



        // 重建左子树  
        int nodeNumLeft = rootPositionInOrder;  
        char* pPreOrderLeft = PreOrder + 1;  
        char* pInOrderLeft = InOrder + nodeNumLeft;  
        _pRoot->_pLeft = RebuildBinaryTree(pPreOrderLeft, pInOrderLeft, nodeNumLeft);  

        // 重建右子树  
        int nodeNumRight = length - nodeNumLeft - 1;  
        char* pPreOrderRight = PreOrder + 1 + nodeNumLeft;  
        char* pInOrderRight = InOrder + nodeNumLeft + 1;  
        _pRoot->_pRight = RebuildBinaryTree(pPreOrderRight, pInOrderRight, nodeNumRight);  
        return _pRoot;  
    }


private:
    void _CreateTree(Node*& pRoot, const T array[], 
        size_t size, size_t& index, const T& invalid)
    {
        if(index < size && (array[index] != invalid))//两个顺序不可调换，否则会导致越界访问
        {
            //创建根节点
            pRoot = new Node(array[index]);

            //创建根结点左子树
            _CreateTree(pRoot->_pLeft, array, size, ++index, invalid);

            //创建根结点左子树
            _CreateTree(pRoot->_pRight, array, size, ++index, invalid);
        }
    }

    Node* _CopyBinaryTree(Node* pRoot)
    {
        if(pRoot)
        {
            Node* pNewNode = new Node(pRoot->_data);
            pNewNode->_pLeft = _CopyBinaryTree(pRoot->_pLeft);
            pNewNode->_pRight = _CopyBinaryTree(pRoot->_pRight);
            return pNewNode;
        }
        return NULL;
    }

    void _DestroyTree(Node* &pRoot)
    {
        if(pRoot)
        {
            _DestroyTree(pRoot->_pLeft);
            _DestroyTree(pRoot->_pRight);
            delete pRoot;
            pRoot = NULL;
        }
    }

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

    void _InOrder(Node* pRoot)
    {
        if(pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout<<pRoot->_data<<" ";
            _InOrder(pRoot->_pRight);
        }

    }

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

    void _LevelOrder(Node* pRoot)
    {
        if(pRoot == NULL)
            return;
        queue<Node*> q;
        q.push(pRoot);
        Node* pCur = NULL;

        while(!q.empty())
        {
            pCur = q.front();
            cout<<pCur->_data<<" ";
            if(pCur->_pLeft)
                q.push(pCur->_pLeft);
            if(pCur->_pRight)
                q.push(pCur->_pRight);
            q.pop(); 
        }
    }

    Node* _GetParent(Node* pRoot, Node* x)
    {
        if(pRoot == NULL || x ==  NULL || x == pRoot)
            return NULL;

        if(pRoot->_pLeft == x || pRoot->_pRight == x)
            return pRoot;

        Node* parent = NULL;
        if(parent = _GetParent(pRoot->_pLeft, x))
            return parent;

        if(parent = _GetParent(pRoot->_pRight, x))
            return parent;

        return NULL;
    }

    Node* _Find(Node* pRoot, const T& value)
    {
        if(pRoot == NULL)  //空树
            return NULL;

        if(pRoot->_data == value)  
            return pRoot;

        Node* pCur = NULL;//如果不用返回值接收需要再调用一次函数
        if(pCur = _Find(pRoot->_pLeft, value))
            return pCur;

        if(pCur = _Find(pRoot->_pRight, value))
        return pCur;
    }

    size_t _Height(Node* pRoot)
    {
        if(pRoot == NULL)  //空树
            return 0;

        if(pRoot->_pLeft == NULL || pRoot->_pRight == NULL)
            return 1;   //只有一个根节点的树

        size_t lefthHight = _Height(pRoot->_pLeft);
        size_t rightHeight = _Height(pRoot->_pRight);

        return (lefthHight>rightHeight) ? (lefthHight+1) : (rightHeight+1);
    }

    size_t _GetLeefNode(Node* pRoot)
    {
        if(pRoot == NULL) //空树
            return 0;

        if(pRoot->_pLeft == NULL && pRoot->_pRight == NULL)
            return 1;  //只有一个根节点的树

        return _GetLeefNode(pRoot->_pLeft) + _GetLeefNode(pRoot->_pRight);
    }

    size_t _GetKLevelNode(Node* pRoot, size_t k)
    {
        if(pRoot == NULL || k<1 || k>_Height(pRoot))
            return 0;

        if(k == 1)
            return 1;

        size_t left = _GetKLevelNode(pRoot->_pLeft, k-1);
        size_t right = _GetKLevelNode(pRoot->_pRight, k-1);

        return left + right;
    }

    void _GetBinaryMirror(Node* pRoot)
    {
        if(pRoot == NULL)
            return ;

        if(pRoot->_pLeft == NULL && pRoot->_pRight == NULL)
            return ;

        swap(pRoot->_pLeft, pRoot->_pRight);

        if(pRoot->_pLeft)
             _GetBinaryMirror(pRoot->_pLeft);

        if(pRoot->_pRight)
             _GetBinaryMirror(pRoot->_pRight);
    }


    bool GetNodePath(Node* pRoot, Node* pNode, list<Node*>& path)
    {
        if(pRoot == pNode)  
        {     
            path.push_back(pRoot);  
            return true;  
        }  

        if(pRoot == NULL)  
            return false;  

        path.push_back(pRoot);  
        bool found = false; 

        found = GetNodePath(pRoot->_pLeft, pNode, path);  //在左子树中寻找

        if(!found)  //在左子树中没有找到，在右子树中寻找
            found = GetNodePath(pRoot->_pRight, pNode, path); 

        if(!found)   //没有找到该节点
            path.pop_back();  
        return found;
    }

    Node* _GetLastCommonParent(Node* pRoot, Node* Node1, Node* Node2)
    {
        if(pRoot == NULL || Node1 == NULL || Node2 == NULL)
            return NULL;

        list<Node*> l1;
        bool Result1 = GetNodePath(pRoot, Node1, l1);

        list<Node*> l2;
        bool Result2 = GetNodePath(pRoot, Node2, l2);

        if(!Result1 || !Result2)
            return NULL;

        Node * pLast = NULL;  
        list<Node*>::const_iterator iter1 = l1.begin();  
        list<Node*>::const_iterator iter2 = l2.begin();

        while(iter1 != l1.end() && iter2 != l2.end())  
        {  
            if(*iter1 == *iter2)  
                pLast = *iter1;  
            else  
                break;  
            iter1++;  
            iter2++;  
        }  
        return pLast;
    }

private:
    BinaryTreeNode<T>* _pRoot;
};

void FunTest()
{
    char array[] = "124##5##36##7##";
    BinaryTree<char> tree(array, strlen(array), '#');
    BinaryTree<char> t(tree);
    BinaryTree<char> t1;
    t1 = t;

    BinaryTreeNode<char>* pCur = NULL;
    pCur = t.GetParent(t.Find('1')); //找到节点的双亲节点
    if(pCur)
        cout<<"结点1的双亲结点为："<<pCur->_data<<endl;

    pCur = t.GetParent(t.Find('2'));
    if(pCur)
        cout<<"结点2的双亲结点为："<<pCur->_data<<endl;

    pCur = t.GetParent(t.Find('5'));
    if(pCur)
        cout<<"结点5的双亲结点为："<<pCur->_data<<endl;


    pCur = t.GetLeftChild(t.Find('1')); //找到结点的左孩子
    if(pCur)
        cout<<"结点1的左孩子为："<<pCur->_data<<endl;

    pCur = t.GetLeftChild(t.Find('3'));
    if(pCur)
        cout<<"结点2的左孩子为："<<pCur->_data<<endl;

    pCur = t.GetLeftChild(t.Find('6'));
    if(pCur)
        cout<<"结点6的左孩子为："<<pCur->_data<<endl;

    pCur = t.GetRightChild(t.Find('1')); //找到结点的右孩子
    if(pCur)
        cout<<"结点1的右孩子为："<<pCur->_data<<endl;

    pCur = t.GetRightChild(t.Find('2'));
    if(pCur)
        cout<<"结点2的右孩子为："<<pCur->_data<<endl;

    pCur = t.GetRightChild(t.Find('5'));
    if(pCur)
        cout<<"结点5的右孩子为："<<pCur->_data<<endl;


    cout<<"二叉树的高度:"<<t.Height()<<endl;
    cout<<"二叉树的叶子节点:"<<t.GetLeefNode()<<endl;
    cout<<"二叉树第三层的节点数："<<t.GetKLevelNode(3)<<endl;
    cout<<"二叉树第二层的节点数："<<t.GetKLevelNode(2)<<endl;
    cout<<"二叉树第一层的节点数："<<t.GetKLevelNode(1)<<endl;
    cout<<"二叉树第四层的节点数："<<t.GetKLevelNode(4)<<endl;


    tree.PreOrder();
    t.PreOrder_Nor();

    tree.InOrder();
    t.InOrder_Nor();

    tree.PostOrder();
    tree.PostOrder_Nor();

    tree.LevelOrder();  

    tree.GetBinaryMirror_Nor();
    tree.GetBinaryMirror();

    cout<<"二叉树是不是完全二叉树："<<t.IsCompleteBinaryTree()<<endl;
    pCur = tree.GetLastCommonParent(tree.Find('2'), tree.Find('6'));
    if(pCur)
        cout<<"结点2和5的公共祖先是"<<pCur->_data<<endl;

    char str1[] = {'1', '2', '4', '5', '3', '6', '7'};
    char str2[] = {'4', '2', '5', '1', '6', '3', '7'};
    tree.RebuildBinaryTree(str1, str2, 7);
}

int main()
{
    FunTest();
    system("pause");

    return 0;
}