递归类型
按照编程技巧分啪
一、将复杂问题分解成两个子问题
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;
}
}