6.重建二叉树

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

struct BinaryTreeNode
{
    int     m_nValue;
    BinaryTreeNode* m_pLeft;
    BinaryTreeNode* m_pRight;
};

BinaryTreeNode* ConstructCore(int* startPreorder, int* endPreorder, int* startInorder, int* endInorder)
{
    //前序遍历的第一个数字是根节点的值
    int rootValue = startPreorder[0];
    BinaryTreeNode* root = new BinaryTreeNode();
    root->m_nValue = rootValue;
    root->m_pLeft = root->m_pRight = nullptr;

    //这棵树仅有根节点一个节点
    if(startPreorder == endPreorder)
    {
        if(startInorder == endInorder
                && *startPreorder == *endInorder)
        {
            return root;
        }
        //else
        //  throw std::exception("Invalid input.");
    }

    //在中序遍历中找到根节点的值
    int* rootInorder = startInorder;
    while(rootInorder <= endInorder && *rootInorder != rootValue)
    {
        ++ rootInorder;
    }


    //在中序遍历中没有找到根节点的值
    if(rootInorder == endInorder && *rootInorder != rootValue)
    {
        //throw std::exception("invalid input.");
    }

    int leftLength = rootInorder - startInorder;
    int* leftPreorderEnd = startPreorder + leftLength;

    //构建左子树
    if(leftLength >0)
    {
        root->m_pLeft = ConstructCore(startPreorder+1, leftPreorderEnd,
                                      startInorder, rootInorder-1);
    }

    //构建右子树
    if(leftLength < endPreorder-startPreorder)
    {
        root->m_pRight = ConstructCore(leftPreorderEnd+1, endPreorder,
                                       rootInorder+1, endInorder);
    }

    return root;

}

BinaryTreeNode* Construct(int* preorder, int* inorder, int length)
{
    return ConstructCore(preorder, preorder+length-1,
                         inorder, inorder+length-1);
};

//先序遍历
void Preorder(BinaryTreeNode* root)
{
    if(root != nullptr)
    {
        cout<<root->m_nValue<<" ";
        Preorder(root->m_pLeft);
        Preorder(root->m_pRight);
    }
}

//中序遍历
void Inorder(BinaryTreeNode* root)
{
    if(root != nullptr)
    {

        Inorder(root->m_pLeft);
        cout<<root->m_nValue<<" ";
        Inorder(root->m_pRight);
    }
}

//后续
void Postorder(BinaryTreeNode* root)
{
    if(root != nullptr)
    {

        Postorder(root->m_pLeft);
        Postorder(root->m_pRight);
        cout<<root->m_nValue<<" ";
    }
}


//层次遍历
void Levelorder(BinaryTreeNode* root)
{
    if(root == nullptr)
        return;

    queue<BinaryTreeNode*> nodes;

    BinaryTreeNode* p = root;
    nodes.push(p);

    while(!nodes.empty())
    {
        p = nodes.front();
        cout<<p->m_nValue<<" ";
        nodes.pop();

        if(p->m_pLeft != nullptr)
            nodes.push(p->m_pLeft);

        if(p->m_pRight != nullptr)
            nodes.push(p->m_pRight);
    }

}


//非递归先序遍历
void NPreorder(BinaryTreeNode* root)
{
    if(root == nullptr)
        return ;

    stack <BinaryTreeNode*> nodes;
    nodes.push(root);

    BinaryTreeNode* pNode = nullptr;


    while(!nodes.empty())
    {
        pNode = nodes.top();
        nodes.pop();

        while(pNode)
        {
            cout<<pNode->m_nValue<<" "; //先访问左子树上的根

            if(pNode->m_pRight) //右子树压栈
                nodes.push(pNode->m_pRight);

            pNode = pNode->m_pLeft; //左子树
        }
    }
}

//非递归中序遍历
void NInorder(BinaryTreeNode* root)
{
    if(root == nullptr)
        return ;

    stack<BinaryTreeNode*> nodes;

    BinaryTreeNode* pNode = root;

    while(!nodes.empty() || pNode != nullptr)
    {

        while(pNode)
        {
            nodes.push(pNode);
            pNode = pNode->m_pLeft;
        }

        pNode = nodes.top();
        nodes.pop();

        cout<<pNode->m_nValue<<" ";

        pNode = pNode->m_pRight;

    }

}



int main()
{
    int preo[] = {1,2,4,7,3,5,6,8};
    int ino[] =  {4,7,2,1,5,3,8,6};

    BinaryTreeNode* root = Construct(preo, ino, sizeof(preo)/sizeof(preo[0]));

    cout<<"先序遍历：";
    Preorder(root);

    cout<<endl<<"N先序遍历：";
    Preorder(root);

    cout<<endl<<"中序遍历：";
    Inorder(root);

    cout<<endl<<"N中序遍历：";
    NInorder(root);

    cout<<endl<<"后序遍历: ";
    Inorder(root);

    cout<<endl<<"层次遍历: ";
    Levelorder(root);

    return 0;
}