二叉树算法练习递归类型汇总
递归类型
按照编程技巧分啪
一、将复杂问题分解成两个子问题
1、平衡二叉树（LeetCode题库110题）
自上而下：算每个节点的平衡因子（即左右子树的高度差），判断是否满足条件。
可以分成两个子问题：求树的高度，和遍历树判断每个节点的是否满足条件
class Solution { public boolean isBalanced(TreeNode root) { if(root == null) { return true; }else { //判断根结点是否满足平衡因子 int ldepth = depth(root.left); int rdepth = depth(root.right); System.out.println(ldepth + " " + rdepth); if(Math.abs(ldepth - rdepth) > 1) { return false; } //判断左子树是否满足平衡因子 if(!isBalanced(root.left)) { return false; } //判断右子树是否满足平衡因子 if(!isBalanced(root.right)) { return false; } return true; } } private int depth(TreeNode root) { int l = 0; int r = 0; int max = 0; if(root == null) { return 0; }else { l = depth(root.left); r = depth(root.right); max = Math.max(l,r); return (max + 1); } } }
自下而上：在求深度的过程中，只要有一个子树不满足条件，就一路返回-1
class Solution { public boolean isBalanced(TreeNode root) { return depth(root) == -1 ? false : true; } private int depth(TreeNode root) { if(root == null){ return 0; }else{ int l = depth(root.left); if(l==-1) return -1; int r = depth(root.right); if(r == -1) return -1; if(Math.abs(l-r) > 1) { return -1; } return Math.max(l,r) + 1; } } }
2、二叉树的直径（LeetCode题库543题）
注意此题是有题眼的，一般题干说树的XX，都是在求子树XX的最大值
所以此题就是再求过某个节点的最长路径，只要把每个节点的最长路径求出来，取最大即可；
最大路径一定产生在左右子树的两边，所以要求树的高度。
这样就转换成了两个问题，求树的高度，以及求过每个节点的最长路径
class Solution { public int diameterOfBinaryTree(TreeNode root) { if(root == null) { return 0; }else { int l = depth(root.left); int r = depth(root.right); int d = l + r; int dl = diameterOfBinaryTree(root.left); int dr = diameterOfBinaryTree(root.right); return Math.max(Math.max(d,dl),Math.max(dl,dr)); } } private int depth(TreeNode root) { int l = 0; int r = 0; int max = 0; if(root == null) { return 0; }else { l = depth(root.left); r = depth(root.right); max = Math.max(l,r); return (max + 1); } } }
3、路径总和III（LeetCode题库437题）
此题的思路也是将复杂的问题分解：我们可以会求一个特定的开始点到任意结束点的符合条件的路径吧，再把树中的每个点遍历一遍，不就是相当于任意起点了吗
class Solution { public int pathSum(TreeNode root, int sum) { if(root == null) { return 0; }else { int count = getPathFromRoot(root,sum); count = count + pathSum(root.left,sum); count = count + pathSum(root.right,sum); return count; } } //求从根节点开始到任意节点结束的合适路径 private int getPathFromRoot(TreeNode root, int sum) { if(root == null) { return 0; }else { int count = 0; sum = sum - root.val; if(sum == 0 ) { count++; } count = count + getPathFromRoot(root.left,sum); count = count + getPathFromRoot(root.right,sum); return count; } } }
4、树的子树（LeetCode题库572题）
思路分解：先写出判断两颗树是否相等的代码，在遍历一遍树，看有没有符合条件的子树
class Solution { public boolean isSubtree(TreeNode s, TreeNode t) { if(s == null) { return false; }else { if(isEquals(s,t)) { return true; } return isSubtree(s.left,t) || isSubtree(s.right,t); } } private boolean isEquals(TreeNode s, TreeNode t) { if(s == null || t == null) { if(s == null && t == null) { return true; }else { return false; } }else { if(s.val != t.val) { return false; }else { return isEquals(s.left,t.left) && isEquals(s.right,t.right); } } } }
二、"||" 与 "&&"
这一类题，是说左右子树有一个满足就返回true，或是都满足才返回true
1、路径总和（LeetCode题库112题）
class Solution { //算出每个节点剩余sum值 public boolean hasPathSum(TreeNode root, int sum) { if(root == null) { return false; }else { sum = sum - root.val; //相当于在前序遍历中找到一个叶子节点且剩余值为0的 if(root.left == null && root.right == null && sum == 0) { return true; } return hasPathSum(root.left,sum) || hasPathSum(root.right,sum); } } //注意在返回值是bool型的递归函数中不可以随便定义int类型数据 }
2、树的子树（572题）同上面
三、条件控制
这类题在条件的控制上面有一点难度。
1、合并二叉树（LeetCode题库617题）
class Solution { public TreeNode mergeTrees(TreeNode t1, TreeNode t2) { if(t1 == null || t2 == null) { return t1 == null ? t2 : t1; }else { t1.val = t1.val + t2.val; t1.left = mergeTrees(t1.left,t2.left); t1.right = mergeTrees(t1.right,t2.right); return t1; } } }
2、树的最小深度（LeetCode题库111题）
class Solution { public int minDepth(TreeNode root) { if(root == null) { return 0; }else { int l = 0; int r = 0; l = minDepth(root.left); r = minDepth(root.right); if(root.left == null || root.right == null) return l + r + 1; else return Math.min(l,r) + 1; } } }
四、变换思路
1、左叶子之和（LeetCode题库404题）
由于要判断”左“所以需要一个父指针，递归是没有办法来使用父指针的，所以想到非递归遍历树
方法一：非递归法
class Solution { public int sumOfLeftLeaves(TreeNode root) { if(root == null) { return 0; }else { Stack<TreeNode> stack = new Stack<>(); TreeNode p = root; int sum = 0; while(!stack.isEmpty() || p != null) { while(p != null) { stack.push(p); p = p.left; } if(!stack.isEmpty()) { p = stack.pop(); if(p.left==null&&p.right==null) { if(!stack.isEmpty()) { if(stack.peek().left==p) sum = sum + p.val; } } p = p.right; } } return sum; } } }
方法二：递归法
虽然递归没办法给我们带来父指针，但是我们可以转换一下思路，将问题转换成判断结点的左孩子是不是叶子节点
class Solution { public int sumOfLeftLeaves(TreeNode root) { if(root == null) { return 0; }else { int sum = 0; if(isLeaf(root.left)) { sum = sum + root.left.val; }else { sum = sum + sumOfLeftLeaves(root.left); } sum = sum + sumOfLeftLeaves(root.right); return sum; } } boolean isLeaf(TreeNode leaf) { if(leaf == null) return false; else if(leaf.left == null && leaf.right == null) return true; else return false; } }
