代码随想录第17天 | 二叉树part04

代码随想录算法训练营第17天 | 二叉树part04 |110.平衡二叉树 257. 二叉树的所有路径 404.左叶子之和

题目一 110.平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点的左右两个子树的高度差的绝对值不超过1。

强调概念：

• 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。从上向下，如同从地面到坑底，从0或1增加。
• 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。从下向上，如同从地面到高山，从0或1增加。

本题同样使用递归(DFS)。在主函数之外使用一个递归函数，如果为AVL则返回树的高度，不是则返回-1.

递归三步曲分析：

1. 明确递归函数的参数和返回值
   参数：当前传入节点。
   返回值：以当前传入节点为根节点的树的高度。

那么如何标记左右子树是否差值大于1呢？
如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，还返回高度的话就没有意义了。
所以如果已经不是二叉平衡树了，可以返回-1 来标记已经不符合平衡树的规则了。

2. 明确终止条件
   递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的树高度为0。

3. 明确单层递归的逻辑
   如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？
   当然是其左子树高度和其右子树高度的差值。
   分别求出其左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。

class Solution 
{
    public boolean isBalanced(TreeNode root) {
        if(root == null)
            return true;
        return getlength(root) == -1 ? false : true;
    }
    public int getlength(TreeNode root)
    {
        if(root == null)
            return 0;
        
        int leftnum = getlength(root.left);
        if(leftnum == -1)
            return -1;
        int rightnum = getlength(root.right);
        if(rightnum == -1)
            return -1;
        
        if( Math.abs(leftnum - rightnum) > 1)
            return -1;
        else 
        {
            return 1 + Math.max(leftnum, rightnum);
        }
    }
}

题目二 257. 二叉树的所有路径

给定一个二叉树，返回所有从根节点到叶子节点的路径。
说明: 叶子节点是指没有子节点的节点。

这道题目要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点直接后续指向孩子节点，找到对应的路径。而中序和后序无法实现。

在这道题目中将第一次涉及到回溯，因为我们要把路径记录下来，需要回溯来回退一个路径再进入另一个路径。
使用一个线性的数据结构来进行回溯操作。比如1->2->5变成1->3，就得先弹出5，然后弹出2，回溯两步之后再把3加进来。
本题需要一个字符串数组来储存路径数据，每条路径用一条字符串表示。

什么时候算是找到了叶子节点？ 是当 cur不为空，其左右孩子都为空的时候，就找到叶子节点。因此结束条件为now.left == null && now.right == null 。
因为对于n个节点只需要n-1个箭头连接，因此最后一个节点应该在循环外打印。

有关回溯：
回溯和递归是一一对应的，有一个递归，就要有一个回溯，这么写的话相当于把递归和回溯拆开了， 一个在花括号里，一个在花括号外。
所以回溯要和递归永远在一起，世界上最遥远的距离是你在花括号里，而我在花括号外！
那么代码应该这么写：

if (cur->left) {
    traversal(cur->left, path, result);
    path.pop_back(); // 回溯
}
if (cur->right) {
    traversal(cur->right, path, result);
    path.pop_back(); // 回溯
}

代码实现如下。注意path是存储每条路需要的节点，由StringBuilder类型的apath转为字符串实现；最后由一个全局的字符串数组ans储存(不用每次传参都把数组传进函数中)。

class Solution {
    public List<String> ans = new ArrayList<>();
    public List<String> binaryTreePaths(TreeNode root) {
        if(root == null)
            return ans;

        List<Integer> path = new ArrayList<>();
        getpath(root, path);
        return ans;
    }
    
    private void getpath(TreeNode now, List<Integer> path)
    {
        path.add(now.val);//根节点
        //end
        if(now.left == null && now.right == null)
        {
            StringBuilder apath = new StringBuilder();
            
            for(int i=0; i<path.size() - 1; i++)//除去最后一个节点
            {
                apath.append( path.get(i) );//path[i]
                apath.append("->")  ;
            }
            apath.append( path.get( path.size() - 1) );
            ans.add( apath.toString() );
            return;
        }
        
        //recursion
        if(now.left != null)
        {
            getpath(now.left, path);
            path.remove(path.size() - 1);
        }
        if(now.right != null)
        {
            getpath(now.right, path);
            path.remove(path.size() - 1);
        }
    }
}

上面的做法是将节点数据和打印的箭头分开，避免了回溯时处理“->”箭头的麻烦。
如果我们直接对字符串进行回溯，记得要回溯两次，一次是">“, 一次是”-".

使用迭代法需要用到栈。但是是两个栈。
除了模拟递归需要一个栈，同时还需要一个栈来存放对应的遍历路径。
使用java可以直接定义一个成员变量为object的栈Stack<Object> stack = new Stack<>();，这样就不用定义两个栈了，都放到一个栈里就可以了。

class Solution {
    /**
     * 迭代法
     */
    public List<String> binaryTreePaths(TreeNode root) 
    {
        List<String> result = new ArrayList<>();
        if (root == null)
            return result;
        Stack<Object> stack = new Stack<>();
        // 节点和路径同时入栈
        stack.push(root);
        stack.push(root.val + "");
        while (!stack.isEmpty()) {
            // 节点和路径同时出栈
            String path = (String) stack.pop();
            TreeNode node = (TreeNode) stack.pop();
            // 若找到叶子节点
            if (node.left == null && node.right == null) {
                result.add(path);
            }
            //右子节点不为空
            if (node.right != null) {
                stack.push(node.right);
                stack.push(path + "->" + node.right.val);
            }
            //左子节点不为空
            if (node.left != null) {
                stack.push(node.left);
                stack.push(path + "->" + node.left.val);
            }
        }
        return result;
    }
}

题目三 404.左叶子之和

计算给定二叉树的所有左叶子之和。不是每层最左边的节点。

注意左叶子的定义：某个节点是父节点的左节点，且它本身没有子节点。
因此临界条件可以这样写：某个节点左孩子不空，左孩子的左右节点为空。
因为不能判断本节点是不是左叶子节点，此时就要通过节点的父节点来判断其左孩子是不是左叶子了。
平时我们解二叉树的题目时，已经习惯了通过节点的左右孩子判断本节点的属性，而本题我们要通过节点的父节点判断本节点的属性。

我们需要根据每次递归函数的返回值来叠加计算得到结果。因此使用后序遍历(左右中)，
先分别计算左右子树的左叶子节点(注意右子树也是会有左叶子节点的)，最后中序时将它们加起来。

class Solution 
{
    public int sumOfLeftLeaves(TreeNode root) 
    {
        if(root == null)
            return 0;
        if(root.left == null && root.right == null)
            return 0;
        
        int leftleaf = sumOfLeftLeaves(root.left);//左子树的左叶子
        if(root.left != null && root.left.left == null && root.left.right == null)
        {
            leftleaf = root.left.val;
        }
        int rightleftleaf = sumOfLeftLeaves(root.right);//右子树的左叶子
        int sum = leftleaf + rightleftleaf;
        return sum;
    }
}

迭代版本其实方便，前中后序都可以。只要统计出左叶子节点就行。
迭代版本：

class Solution {
    public int sumOfLeftLeaves(TreeNode root) 
    {
        if (root == null) 
	        return 0;
        Stack<TreeNode> stack = new Stack<> ();
        stack.add(root);
        int result = 0;
        while ( !stack.isEmpty() ) 
        {
            TreeNode node = stack.pop();
            if (node.left != null && node.left.left == null && node.left.right == null) 
            {
                result += node.left.val;
            }
            if (node.right != null) 
	            stack.add(node.right);
            if (node.left != null) 
	            stack.add(node.left);
        }
        return result;
    }
}