代码随想录第18天 | 二叉树 part05

代码随想录算法训练营第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;
    }
}