构造二叉树有两种办法
- 前序+中序
- 后序+中序
这两种方法的思路是相同的，都是用前序（第一个元素）或者后序（最后一个元素）来对中序数组进行划分成左右数组，再根据划分的中序数组的大小来划分前序/后序数组。
由于需要不断的进行划分，我们首先想到的是递归的办法
- 递归的返回值一定是TreeNode型的，因为需要根据新建的结点构建二叉树；
- 递归的参数列表有对数组的引用，有前序/后序的起始和终止，有中序的起止和终止；
- 递归的主体部分是对数组的划分；再进行root->left和root->right 的递归求值；
106. 从中序与后序遍历序列构造二叉树
106. 从中序与后序遍历序列构造二叉树
根据一棵树的中序遍历与后序遍历构造二叉树。
注意:
你可以假设树中没有重复的元素。
例如，给出
中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]
返回如下的二叉树：
3
/ \
9 20
/ \
15 7
通过次数72,987提交次数103,285
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
if(inorder.size()==0||postorder.size()==0) return NULL;
return traversal(inorder,0,inorder.size(),postorder,0,postorder.size());
}
TreeNode* traversal(vector<int>& inorder,int inorderbegin,int inorderend,vector<int>& postorder,int postorderbegin,int postorderend){
//终止条件，当后序数组大小为0的时候，返回NULL
if(postorderbegin==postorderend) return NULL;
//当后序数组的大小不为0的时候找到新的划分值
int rootvalue=postorder[postorderend-1];
TreeNode* root=new TreeNode(rootvalue);
if(postorderbegin-postorderend==1) return root;
//在中序数组中划分
int delemiter;
for(delemiter=inorderbegin;delemiter<inorderend;delemiter++){
if(inorder[delemiter]==rootvalue) break;
}
//中序划分为两部分，分别为 leftInorderBegin-leftInorderEnd rightInorderBegin-rightInorderEnd
int leftinorderbegin=inorderbegin;
int leftinorderend=delemiter;
int rightinorderbegin=delemiter+1;
int rightinorderend=inorderend;
//划分后序数组为两部分，分别为 leftPostorderBegin-leftPostorderEnd rightPostorderBegin-rightPostorderEnd
int leftpostorderbegin=postorderbegin;
int leftpostorderend=postorderbegin+delemiter-inorderbegin;
int rightpostorderbegin=postorderbegin+delemiter-inorderbegin;//左开右闭
int rightpostorderend=postorderend;排除最后一个元素
root->left=traversal(inorder,leftinorderbegin,leftinorderend,postorder,leftpostorderbegin,leftpostorderend);
root->right=traversal(inorder,rightinorderbegin,rightinorderend,postorder,rightpostorderbegin,rightpostorderend);
return root;
}
105. 从前序与中序遍历序列构造二叉树
105. 从前序与中序遍历序列构造二叉树
根据一棵树的前序遍历与中序遍历构造二叉树。
注意:
你可以假设树中没有重复的元素。
例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：
3
/ \
9 20
/ \
15 7
/**
* 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>& preorder, vector<int>& inorder) {
if(preorder.size()==0||inorder.size()==0) return NULL;
return traversal(preorder,0,preorder.size(),inorder,0,inorder.size());
}
TreeNode* traversal(vector<int>& preorder,int preorderBegin,int preorderEnd,vector<int>& inorder,int inorderBegin,int inorderEnd){
//结束条件
if(preorderBegin==preorderEnd) return NULL;
//int rootvalue=preorder[0];//在右半边的时候是错误的
int rootvalue=preorder[preorderBegin];
TreeNode* root=new TreeNode(rootvalue);
if(preorderEnd-preorderBegin==1) return root;
//用前序的首字母来划分中序
int delemiter;
for(delemiter=inorderBegin;delemiter<inorderEnd;delemiter++){
if(inorder[delemiter]==rootvalue) break;
}
//中序划分
int leftInorderBegin=inorderBegin;
int leftInorderEnd=delemiter;
int rightInorderBegin=delemiter+1;
int rightInorderEnd=inorderEnd;
int leftPreBegin=preorderBegin+1;
int leftPreEnd=preorderBegin+1+delemiter-inorderBegin;
int rightPreBegin=preorderBegin+1+delemiter-inorderBegin;
int rightPreEnd=preorderEnd;
root->left=traversal(preorder,leftPreBegin,leftPreEnd,inorder,leftInorderBegin,leftInorderEnd);
root->right=traversal(preorder,rightPreBegin,rightPreEnd,inorder,rightInorderBegin,rightInorderEnd);
return root;
}
};
补充
654. 最大二叉树
654. 最大二叉树
给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：
二叉树的根是数组中的最大元素。
左子树是通过数组中最大值左边部分构造出的最大二叉树。
右子树是通过数组中最大值右边部分构造出的最大二叉树。
通过给定的数组构建最大二叉树，并且输出这个树的根节点。
示例 ：
输入：[3,2,1,6,0,5]
输出：返回下面这棵树的根节点：
6
/ \
3 5
\ /
2 0
\
1
提示：
给定的数组的大小在 [1, 1000] 之间。
/**
* 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* constructMaximumBinaryTree(vector<int>& nums) {
if(nums.size()==0) return NULL;
return traversal(nums,0,nums.size());
}
TreeNode* traversal(vector<int>& nums,int begin,int end){
if(begin==end) return NULL;
int delemiter=0;
for(int i=1;i<nums.size();i++){
if(nums[i]>nums[delemiter])
delemiter=i;
}
int rootvalue=nums[delemiter];
TreeNode* root=new TreeNode(rootvalue);
if(end-begin==0) return root;
vector<int> left(nums.begin(),nums.begin()+delemiter);
vector<int> right(nums.begin()+delemiter+1,nums.end());
root->left=traversal(left,0,left.size());
root->right=traversal(right,0,right.size());
return root;
}
};
998. 最大二叉树 II
998. 最大二叉树 II
最大树定义：一个树，其中每个节点的值都大于其子树中的任何其他值。
给出最大树的根节点 root。
就像之前的问题那样，给定的树是从表 A（root = Construct(A)）递归地使用下述 Construct(A) 例程构造
如果 A 为空，返回 null
否则，令 A[i] 作为 A 的最大元素。创建一个值为 A[i] 的根节点 root
root 的左子树将被构建为 Construct([A[0], A[1], ..., A[i-1]])
root 的右子树将被构建为 Construct([A[i+1], A[i+2], ..., A[A.length - 1]])
返回 root
请注意，我们没有直接给定 A，只有一个根节点 root = Construct(A).
假设 B 是 A 的副本，并附加值 val。保证 B 中的值是不同的。
返回 Construct(B)。
示例 1：
输入：root = [4,1,3,null,null,2], val = 5
输出：[5,4,null,1,3,null,null,2]
解释：A = [1,4,2,3], B = [1,4,2,3,5]
示例 2：
输入：root = [5,2,4,null,1], val = 3
输出：[5,2,4,null,1,null,3]
解释：A = [2,1,5,4], B = [2,1,5,4,3]
示例 3：
输入：root = [5,2,3,null,1], val = 4
输出：[5,2,4,null,1,3]
解释：A = [2,1,5,3], B = [2,1,5,3,4]
提示：
1 <= B.length <= 100
通过次数3,948提交次数6,478
/**
* 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* insertIntoMaxTree(TreeNode* root, int val) {
if(root==NULL) return new TreeNode(val);
if(root->val<val) //如果val大于root的值，那么就把root当做值为val节点 左孩子
{
TreeNode*p=new TreeNode(val);
p->left=root;
return p;
}
else{
//插入到root的右子树的相应位置了
root->right=insertIntoMaxTree(root->right,val);
return root;
}
return NULL;
}
};