【数字三角形】

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

typedef int BTDataType;
typedef struct BinaryTreeNode
{
    BTDataType _data;
    struct BinaryTreeNode* _left;
    struct BinaryTreeNode* _right;
    
    BinaryTreeNode(BTDataType data, BinaryTreeNode* left = nullptr, BinaryTreeNode* right = nullptr)
        :_data(data)
        ,_left(left)
        ,_right(right)
    {

    }
}BTNode;

BTNode* _creat(vector<int>& preorder, vector<int>& inorder, int& i, int begin, int end)
{
    if (begin > end)
        return nullptr;

    int x = begin;
    for (x = begin; x <= end; ++x)
    {
        if (inorder[x] == preorder[i])
            break;
    }

    BTNode* root = new BTNode(preorder[i++]);

    root->_right = _creat(preorder, inorder, i, begin, x - 1);
    root->_left = _creat(preorder, inorder, i, x + 1, end);

    return root;
};

BTNode* CreatMirrorTree(vector<int>& preorder, vector<int>& inorder)
{
    int index = 0;
    return _creat(preorder, inorder, index, 0, inorder.size() - 1);
}

void LevelTraverse(BTNode* T)
{
    int flag = 0;
    queue<BTNode*> q;
    if (T != nullptr)
        q.push(T);
    while (!q.empty())
    {
        BTNode* front = q.front();

        if (flag == 0)
        {
            cout << front->_data;
            flag = 1;
        }
        else
            cout << " " << front->_data;

        q.pop();

        if (front->_left)
            q.push(front->_left);
        if (front->_right)
            q.push(front->_right);
    }
}

int main() 
{
    int n = 0;
    cin >> n;

  vector<int> pre(n, 0);
vector<int> in(n, 0);

    for (int i = 0; i < n; i++)
        cin >> in[i];
    for (int i = 0; i < n; i++)
        cin >> pre[i];

    BTNode* root = CreatMirrorTree(pre, in);

    LevelTraverse(root);

    return 0;
}