leetcode 105 从前序与中序遍历构造二叉树

首先是自己想的递归的办法，算是比较简洁，通过前序遍历当前数组第一个数字来将中序遍历的数组分为两部分，分别为当前节点的左子树与右子树，进行递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) 
    {
        TreeNode* This_Node = new TreeNode;
        This_Node->val = preorder[0];
        if(preorder.size() == 1 && inorder.size() == 1)
        return This_Node;
        vector<int>::iterator pos = find(inorder.begin(),inorder.end(),preorder[0]);      //找到pre中首个元素在in中的位置
        int dist_1 = pos - inorder.begin();
        int dist_2 = inorder.end() - pos -1;
        if(dist_1>0)
        {
            vector<int> pre_1(preorder.begin()+1,preorder.begin()+dist_1+1);
            vector<int> in_1(inorder.begin(),pos);
            This_Node->left = buildTree(pre_1,in_1);
        }
        if(dist_2>0)
        {
            vector<int> pre_2(preorder.begin()+dist_1+1,preorder.end());
            vector<int> in_2(pos+1,inorder.end());
            This_Node->right = buildTree(pre_2,in_2);
        }
        return This_Node;
    }
};

迭代的方法，同样是用到了栈的结构，利用的是前序遍历与中序遍历在某几位上会出现顺序倒置，这其实是在连续的不存在右子树的情况下出现的，栈中存放的是未考虑右子树的节点的值，同样有一个指针指向当前最左边的节点的值。对前序进行遍历，若当前元素的前一个元素与指针指向的不同，则将当前元素入栈，否则就不断出栈，指针也不断后移，直到二者对应的元素不同，最后一个相同的节点就是双亲节点。以此类推，一切都在代码中。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) 
    {
        if(!preorder.size())
        return nullptr;
        stack<TreeNode*> st_Tree;
        TreeNode* res = new TreeNode(preorder[0]);
        st_Tree.push(res);
        int inorder_index = 0;
        for(int i = 1 ; i < preorder.size() ; i++)
        {
            int This_val = preorder[i];
            TreeNode* node = st_Tree.top();
            if(node->val != inorder[inorder_index])
            {
                node->left = new TreeNode(This_val);
                st_Tree.push(node->left);
            }
            else
            {
                while(!st_Tree.empty() &&　inorder[inorder_index] == st_Tree.top()->val)
                {
                    node = st_Tree.top();
                    inorder_index++;
                    st_Tree.pop();
                }
                node->right= new TreeNode(This_val);
                st_Tree.push(node->right);
            }
        }   
        return res;     
    }
};