根据后序遍历和中序遍历建树的方法

一，递归，每次将中序和后序重新按照根节点分割

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
            if(inorder.size()!=postorder.size()||!inorder.size()){
                return NULL;
            }
            int value = postorder.back();
            TreeNode * root = new TreeNode(value);
            postorder.pop_back();
            //修改 中序和 后序
            //修改中序
            int len = inorder.size();
            int mark = 0;
            vector<int> newleft,newright;
            for(int i=0;i<len;i++){
                if(value == inorder[i]){
                    mark = i;
                }
            }
            newleft.assign(inorder.begin(),inorder.begin()+mark);
            newright.assign(inorder.begin()+mark+1,inorder.end());

            //修改后序
            vector<int> rnewleft,rnewright;
            if(newleft.size()){
                rnewleft.assign(postorder.begin(),postorder.begin()+newleft.size());
            }
            if(newright.size()){
                rnewright.assign(postorder.begin()+newleft.size(),postorder.end());
            }

            root->left = buildTree(newleft,rnewleft);
            root->right = buildTree(newright,rnewright);
            return root;
    }
};

方法二：迭代

思路

迭代法是一种非常巧妙的实现方法。迭代法的实现基于以下两点发现。

如果将中序遍历反序，则得到反向的中序遍历，即每次遍历右孩子，再遍历根节点，最后遍历左孩子。
如果将后序遍历反序，则得到反向的前序遍历，即每次遍历根节点，再遍历右孩子，最后遍历左孩子。

「反向」的意思是交换遍历左孩子和右孩子的顺序，即反向的遍历中，右孩子在左孩子之前被遍历。

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/solution/cong-zhong-xu-yu-hou-xu-bian-li-xu-lie-gou-zao-14/

class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0) {
            return nullptr;
        }
        auto root = new TreeNode(postorder[postorder.size() - 1]);
        auto s = stack<TreeNode*>();
        s.push(root);
        int inorderIndex = inorder.size() - 1;
        for (int i = int(postorder.size()) - 2; i >= 0; i--) {
            int postorderVal = postorder[i];
            auto node = s.top();
            if (node->val != inorder[inorderIndex]) {
                node->right = new TreeNode(postorderVal);
                s.push(node->right);
            } else {
                while (!s.empty() && s.top()->val == inorder[inorderIndex]) {
                    node = s.top();
                    s.pop();
                    inorderIndex--;
                }
                node->left = new TreeNode(postorderVal);
                s.push(node->left);
            }
        }
        return root;
    }
};