如何根据两个顺序构造⼀个唯⼀的⼆叉树？

本题思路根据Carl大佬整理，大家感兴趣的去关注一波。如果你想提升算法能力，只要跟住代码随想录每天题目的节奏，定会融会贯通，算法能力稳稳的提升一个台阶！

一、⾸先如何根据两个顺序构造⼀个唯⼀的⼆叉树?

1、以中序和后序遍历来说：

就是以后序数组的最后⼀个元素为切割点，先切中序数组，然后根据中序左数组，反过来在切后序数组。⼀层⼀层切下去，每次后序数组最后⼀个元素就是节点元素。

1、接下来想到用递归法
(1)、如果后序数组大小为0，说明是空节点。返回NULL。
(2)、如果不为空，取后序数组最后一个元素作为节点元素。同时再判断一下后序数组大小是不是为1，为1说明是叶子节点直接返回。
(3)、接着找到后序数组最后一个元素在中序数组的位置，作为切割点。
(4)、把中序数组切割成中序左数组和中序右数组。
(5)、把后序数组切割成后序左数组和后序右数组。
(6)、递归处理左区间和右区间。

注意事项：
1、确定切割标准，找好边界值。
2、先切中序数组，因为切割点是后序数组最后一个元素。
3、后序数组没有明确的切割点，但是要记得中序数组大小一定等于后序数组大小。
现在我们把中序数组切成了中序左数组和中序右数组，那么后序数组就可以按照中序左数组的大小来切割，得到后序左数组和后序右数组。

递归法(容器分割)

class Solution{private:TreeNode* traversal(vector<int>&inorder,vector<int>&postorder) {//第一步，判断后序数组大小是否为0if(postorder.size()==0) return NULL;//第二步，找到后序遍历数组最后⼀个元素，就是当前的中间节点，接着判断是不是叶子节点int rootValue=postorder[postorder.size()-1];TreeNode* root=newTreeNode(rootValue);if(postorder.size()==1) return root;//第三步，找到中序遍历的切割点int delimiterIndex;//1从0开始，因为是容器里面装着数组for(delimiterIndex=0;delimiterIndex<inorder.size();delimiterIndex++) {if(inorder[delimiterIndex]==rootValue)break;}//第四步，切割中序数组//左闭右开区间：[0, delimiterIndex)vector<int> leftInorder(inorder.begin(),inorder.begin()+delimiterIndex);// [delimiterIndex + 1, end)vector<int> rightInorder(inorder.begin()+delimiterIndex+1,inorder.end() );// postorder舍弃末尾元素postorder.resize(postorder.size()-1);//第五步，切割后序数组//依然左闭右开，注意这⾥使⽤了左中序数组⼤⼩作为切割点，[0, leftInorder.size)vector<int> leftPostorder(postorder.begin(),postorder.begin()+leftInorder.size());// [leftInorder.size(), end)vector<int> rightPostorder(postorder.begin()+leftInorder.size(),postorder.end());root->left=traversal(leftInorder,leftPostorder);root->right=traversal(rightInorder,rightPostorder);return root;
}
public:TreeNode* buildTree(vector<int>&inorder,vector<int>&postorder{if(inorder.size()==0||postorder.size()==0) return NULL;returntraversal(inorder,postorder);}
};

如上的代码性能并不好，因为每层递归都定义了新的vector（就是数组），既耗时⼜耗空间，但上⾯的代码是最好理解的。

递归法（下表索引分割）

思路是⼀样的，只不过不⽤重复定义vector了，每次⽤下表索引来分割

class Solution{private:// 中序区间： [inorderBegin, inorderEnd)，后序区间[postorderBegin, postorderEnd)TreeNode* traversal(vector<int>& inorder,int inorderbegin,int inorderend,vector<int>& postorder,int postorderbegin,int postorderend){if(postorderbegin==postorderend) return nullptr;int rootValue=postorder[postorderend-1];TreeNode* root=new TreeNode(rootValue);if(postorderend-postorderbegin==1) return root;//找到分割点在中序数组的位置int delimiterIndex;for(delimiterIndex=inorderbegin;delimiterIndex<inorderend;delimiterIndex++){ ///1 ,注意标记法的开始和结束if(inorder[delimiterIndex]==rootValue) break;}//切割中序数组//中序左数组,左闭右开[leftInorderBegin, leftInorderEnd)int leftInorderbegin=inorderbegin;//中序左数组的开始位置int leftInorderend=delimiterIndex;//中序左数组结束位置//中序右数组,左闭右开[rightInorderBegin, rightInorderEnd)int rightInorderbegin=delimiterIndex+1;//中序右数组开始位置int rightInorderend=inorderend;//根据中序左数组大小切割后序数组//后序左数组,左闭右开[leftPostorderBegin, leftPostorderEnd)int leftPostorderbegin=postorderbegin;int leftPostorderend=postorderbegin+(delimiterIndex-inorderbegin);///2//后序右数组,左闭右开[rightPostorderBegin, rightPostorderEnd)int rightPostorderbegin=postorderbegin+(delimiterIndex-inorderbegin);///3int rightPostorderend=postorderend-1;///4 排除最后⼀个元素，已经作为节点了root->left=traversal(inorder,leftInorderbegin,leftInorderend,postorder,leftPostorderbegin,leftPostorderend);root->right=traversal(inorder,rightInorderbegin,rightInorderend,postorder,rightPostorderbegin,rightPostorderend);return root;}
public:TreeNode* buildTree(vector<int>&inorder,vector<int>& postorder){if(inorder.size()==NULL||postorder.size()==NULL) return nullptr;return traversal(inorder,0,inorder.size(),postorder,0,postorder.size());}
};

2、以前序和中序遍历

/*** 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 {private:TreeNode* traversal(vector<int>& preorder,int preorderBegin,int preorderEnd,vector<int>& inorder,int inorderBegin,int inorderEnd ){if(preorderBegin==preorderEnd) return NULL;int rootValue=preorder[preorderBegin];TreeNode* root=new TreeNode(rootValue);if(preorderEnd-preorderBegin==1)  return root;int delimiterIndex;for(delimiterIndex=inorderBegin;delimiterIndex<inorderEnd;delimiterIndex++){if(inorder[delimiterIndex]==rootValue) break;}//切割中序数组int leftInorderBegin=inorderBegin;int leftInorderEnd=delimiterIndex;int rightInorderBeigin=delimiterIndex+1;int rightInorderEnd=inorderEnd;//切割前序数组int leftPreorderBegin=preorderBegin+1;int leftPreorderEnd=preorderBegin+(delimiterIndex-inorderBegin)+1;int rightPreorderBeigin=preorderBegin+(delimiterIndex-inorderBegin)+1;int rightPreorderEnd=preorderEnd;root->left=traversal(preorder,leftPreorderBegin,leftPreorderEnd,inorder,leftInorderBegin,leftInorderEnd);root->right=traversal(preorder,rightPreorderBeigin,rightPreorderEnd,inorder,rightInorderBeigin,rightInorderEnd);return root;}
public:TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {if(preorder.size()==NULL||inorder.size()==NULL) return NULL;return traversal(preorder,0,preorder.size(),inorder,0,inorder.size());}
};