代码随想录算法训练营第18天 | 二叉树 part05
● 513.找树左下角的值● 112. 路径总和 113.路径总和ii● 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树
题目一 ● 513.找树左下角的值
给定一个二叉树,在树的最后一行找到最左边的值。
很显然,使用迭代,即层序遍历方法最简单。
只需要统计最后一行的第一个元素即可。也就是每次迭代,选取第一个元素,直到最后一次循环。
class Solution {
public int findBottomLeftValue(TreeNode root)
{
Queue<TreeNode> que = new LinkedList<>();
if(root != null)
que.offer(root);
int ans = 0;
while( que.isEmpty() != true)
{
int len = que.size();
for(int i=0; i<len; i++)
{
TreeNode popnode = que.poll();
if(i == 0)
ans = popnode.val;
if(popnode.left != null)
que.offer(popnode.left);
if(popnode.right != null)
que.offer(popnode.right);
}
}
return ans;
}
}
而递归法需要用到回溯。
class Solution {
private int curdeep = -1;
private int value = 0;
private void findleft(TreeNode root, int deep)
{
//end
if(root == null)
return;
if(root.left == null && root.right == null)
{
if(deep > curdeep)
{
value = root.val;
curdeep = deep;
}
}
//the middle is not exist.
if(root.left != null)//left
{
deep++;
findleft(root.left, deep );
deep--;//回溯
}
if(root.right != null)//right
{
deep++;
findleft(root.right, deep );
deep--;//回溯
}
}
public int findBottomLeftValue(TreeNode root)
{
int deep = 0;
value = root.val;
findleft(root, deep);
return value;
}
}
因为本题无需对中值进行任何操作,因此前中后序均可实现。
使用curdeep记录当前节点的深度,如果不断深入就继续更新。
题目二 112. 路径总和 113.路径总和ii
给定一个二叉树和一个目标和,判断该树中是否存在根节点到叶子节点的路径,这条路径上所有节点值相加等于目标和。
说明: 叶子节点是指没有子节点的节点。
递归函数什么时候需要返回值?什么时候不需要返回值?这里总结如下三点:
如果需要搜索整棵二叉树且不用处理递归返回值,递归函数就不要返回值。
如果需要搜索整棵二叉树且需要处理递归返回值,递归函数就需要返回值。
如果要搜索其中一条符合条件的路径,那么递归一定需要返回值,因为遇到符合条件的路径了就要及时返回。(本题的情况)
首先容易想到,本题类似于找出二叉树全部路径,可以在遍历的过程中直接比较节点与目标之间的大小,如果小于则继续向下遍历,到达叶子节点时仍小于则不匹配;如果大于则直接判定不匹配。
但比较还是过于麻烦,可以用递减,
让计数器count初始为目标和,然后每次减去遍历路径节点上的数值。
终止情况:
如果最后count == 0,同时到了叶子节点的话,说明找到了目标和。
如果遍历到了叶子节点,count不为0,就是没找到。
class Solution {
public boolean hasPathSum(TreeNode root, int targetSum)
{
if(root == null)
return false;
boolean ans = recursion(root, targetSum - (root.val));
return ans;
}
private boolean recursion(TreeNode cur, int count)
{
//end
if(cur.left == null && cur.right == null && count == 0)
return true;
if(cur.left == null && cur.right == null)
return false;
//left
if(cur.left != null)
{
count -= cur.left.val;
if(recursion(cur.left, count) == true)
return true;
count += cur.left.val;
}
//right
if(cur.right != null)
{
count -= cur.right.val;
if(recursion(cur.right, count) == true)
return true;
count += cur.right.val;
}
return false;
}
}
终止条件是判断叶子节点,所以递归的过程中就不要让空节点进入递归了。
递归函数是有返回值的,对递归函数进行判定,如果递归函数返回true,说明找到了合适的路径,应该立刻返回。
注意我们递归的时候是给count减去节点上的值,回溯时应当加回来。
引申:113. 路径总和ii
给定一个二叉树和一个目标和,找到所有从根节点到叶子节点路径总和等于给定目标和的路径。
用一个二重可变数组返回。
说明: 叶子节点是指没有子节点的节点。
输入:root = [1,2,3], targetSum = 5 输出:[]
路径总和ii要遍历整个树,找到所有路径,所以递归函数不要返回值!
本题实质上是二叉树路径和路径总和的综合题。
path为单条路径的数组,而ans储存所有path。
注意回溯时不仅要还原targetsum,还要把path中存的值删去一个。
class Solution {
public List<List<Integer>> pathSum(TreeNode root, int targetsum)
{
List<List<Integer>> res = new ArrayList<>();
if (root == null)
return res; // 非空判断
List<Integer> path = new LinkedList<>();
preorderdfs(root, targetsum, res, path);
return res;
}
public void preorderdfs(TreeNode root, int targetsum, List<List<Integer>> res, List<Integer> path)
{
path.add(root.val);
// 遇到了叶子节点
if (root.left == null && root.right == null)
{
// 找到了和为 targetsum 的路径
if (targetsum - root.val == 0)
{
res.add(new ArrayList<>(path));
}
return; // 如果和不为 targetsum,返回
}
if (root.left != null)
{
targetsum -= root.val;
preorderdfs(root.left, targetsum, res, path);
targetsum += root.val;
path.remove(path.size() - 1); // 回溯
}
if (root.right != null)
{
targetsum -= root.val;
preorderdfs(root.right, targetsum, res, path);
targetsum += root.val;
path.remove(path.size() - 1); // 回溯
}
}
}
题目三 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树
根据一棵树的中序遍历与后序遍历构造二叉树。
注意: 你可以假设树中没有重复的元素。
如果是中序和后序的话,以后序数组的最后一个元素为切割点,先切中序数组,根据中序数组,反过来再切后序数组。一层一层切下去,每次后序数组最后一个元素就是节点元素。
本题是从两个数组中提取信息进行构建二叉树。
递归步骤如下,先处理后序数组,后处理中序数组,再转回后序数组。
- 第一步:如果数组大小为零的话(两个看一个就行,因为两个属于一棵树),说明是空节点。
- 第二步:如果不为空,那么取后序数组最后一个元素作为节点元素。
- 第三步:找到后序数组最后一个元素在中序数组的位置,作为切割点(二叉树当前的根节点)。
- 第四步:切割中序数组,切成中序左数组和中序右数组(顺序别搞反了,一定是先切中序数组)
- 第五步:切割后序数组,切成后序左数组和后序右数组
- 第六步:递归处理左区间和右区间。
下面是c++版本实现:
class Solution
{
private:
TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
if (postorder.size() == 0) return NULL;
// 后序遍历数组最后一个元素,就是当前的中间节点
int rootValue = postorder[postorder.size() - 1];
TreeNode* root = new TreeNode(rootValue);
// 叶子节点
if (postorder.size() == 1) return root;
// 找到中序遍历的切割点
int delimiterIndex;
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;
return traversal(inorder, postorder);
}
};
上述的方法使用了额外的数组空间来拷贝切割后的数组。因此也可以直接对数组下标进行操作来提取节点元素。方法如下。是真的复杂…
class Solution {
public TreeNode buildTree(int[] inorder, int[] postorder) {
if(postorder.length == 0 || inorder.length == 0)
return null;
return buildHelper(inorder, 0, inorder.length, postorder, 0, postorder.length);
}
private TreeNode buildHelper(int[] inorder, int inorderStart, int inorderEnd, int[] postorder, int postorderStart, int postorderEnd){
if(postorderStart == postorderEnd)
return null;
int rootVal = postorder[postorderEnd - 1];
TreeNode root = new TreeNode(rootVal);
int middleIndex;
for (middleIndex = inorderStart; middleIndex < inorderEnd; middleIndex++){
if(inorder[middleIndex] == rootVal)
break;
}
int leftInorderStart = inorderStart;
int leftInorderEnd = middleIndex;
int rightInorderStart = middleIndex + 1;
int rightInorderEnd = inorderEnd;
int leftPostorderStart = postorderStart;
int leftPostorderEnd = postorderStart + (middleIndex - inorderStart);
int rightPostorderStart = leftPostorderEnd;
int rightPostorderEnd = postorderEnd - 1;
root.left = buildHelper(inorder, leftInorderStart, leftInorderEnd, postorder, leftPostorderStart, leftPostorderEnd);
root.right = buildHelper(inorder, rightInorderStart, rightInorderEnd, postorder, rightPostorderStart, rightPostorderEnd);
return root;
}
}
前序和中序遍历构建二叉树同理。略过不表。相应代码如下。
与上面使用可变数组不同的是,使用了map存储数据,方便根据数值查找位置。
class Solution {
Map<Integer, Integer> map;
public TreeNode buildTree(int[] preorder, int[] inorder) {
map = new HashMap<>();
for (int i = 0; i < inorder.length; i++) { // 用map保存中序序列的数值对应位置
map.put(inorder[i], i);
}
return findNode(preorder, 0, preorder.length, inorder, 0, inorder.length); // 前闭后开
}
public TreeNode findNode(int[] preorder, int preBegin, int preEnd, int[] inorder, int inBegin, int inEnd) {
// 参数里的范围都是前闭后开
if (preBegin >= preEnd || inBegin >= inEnd) { // 不满足左闭右开,说明没有元素,返回空树
return null;
}
int rootIndex = map.get(preorder[preBegin]); // 找到前序遍历的第一个元素在中序遍历中的位置
TreeNode root = new TreeNode(inorder[rootIndex]); // 构造结点
int lenOfLeft = rootIndex - inBegin; // 保存中序左子树个数,用来确定前序数列的个数
root.left = findNode(preorder, preBegin + 1, preBegin + lenOfLeft + 1,
inorder, inBegin, rootIndex);
root.right = findNode(preorder, preBegin + lenOfLeft + 1, preEnd,
inorder, rootIndex + 1, inEnd);
return root;
}
}