二叉树的递归套路

可以解决面试中绝大多数的二叉树问题尤其是树型dp问题，本质是利用递归遍历二叉树的便利性

给定一棵二叉树的头节点head，返回这颗二叉树是不是平衡二叉树

public class IsBalanced {
    

	public static class Node {
    
		public int value;
		public Node left;
		public Node right;

		public Node(int data) {
    
			this.value = data;
		}
	}

	public static boolean isBalanced(Node head) {
    
		return process(head).isBalanced;
	}
	
	public static class Info{
    
		public boolean isBalanced;
		public int height;
		
		public Info(boolean i, int h) {
    
			isBalanced = i;
			height = h;
		}
	}
	
	public static Info process(Node x) {
    
		if(x == null) {
    
			return new Info(true, 0);
		}
		Info leftInfo = process(x.left);
		Info rightInfo = process(x.right);
		int height = Math.max(leftInfo.height, rightInfo.height)  + 1;
		boolean isBalanced = true;
		if(!leftInfo.isBalanced) {
    
			isBalanced = false;
		}
		if(!rightInfo.isBalanced) {
    
			isBalanced = false;
		}
		if(Math.abs(leftInfo.height - rightInfo.height) > 1) {
    
			isBalanced = false;
		}
		return new Info(isBalanced, height);
	}
}

给定一棵二叉树的头节点head，任何两个节点之间都存在距离，返回整棵二叉树的最大距离

public class MaxDistance {
    

	public static class Node {
    
		public int value;
		public Node left;
		public Node right;

		public Node(int data) {
    
			this.value = data;
		}
	}

	public static int maxDistance(Node head) {
    
		return process(head).maxDistance;
	}

	public static class Info {
    
		public int maxDistance;
		public int height;

		public Info(int dis, int h) {
    
			maxDistance = dis;
			height = h;
		}
	}

	public static Info process(Node X) {
    
		if (X == null) {
    
			return new Info(0, 0);
		}
		Info leftInfo = process(X.left);
		Info rightInfo = process(X.right);
		int height = Math.max(leftInfo.height, rightInfo.height) + 1;
		int maxDistance = Math.max(
				Math.max(leftInfo.maxDistance, rightInfo.maxDistance),
				leftInfo.height + rightInfo.height + 1);
		return new Info(maxDistance, height);
	}	
}

（*）给定一棵二叉树的头节点head，返回这颗二叉树中最大的二叉搜索子树的头节点

// 在线测试链接 : https://leetcode.com/problems/largest-bst-subtree

public class MaxSubBSTSize {
    

	// 提交时不要提交这个类
	public static class TreeNode {
    
		public int val;
		public TreeNode left;
		public TreeNode right;

		public TreeNode(int value) {
    
			val = value;
		}
	}

	// 提交如下的代码，可以直接通过
	public static int largestBSTSubtree(TreeNode head) {
    
		if (head == null) {
    
			return 0;
		}
		return process(head).maxBSTSubtreeSize;
	}

	public static class Info {
    
		public int maxBSTSubtreeSize;
		public int allSize;
		public int max;
		public int min;

		public Info(int m, int a, int ma, int mi) {
    
			maxBSTSubtreeSize = m;
			allSize = a;
			max = ma;
			min = mi;
		}
	}

	public static Info process(TreeNode x) {
    
		if (x == null) {
    
			return null;
		}
		Info leftInfo = process(x.left);
		Info rightInfo = process(x.right);
		int max = x.val;
		int min = x.val;
		int allSize = 1;
		if (leftInfo != null) {
    
			max = Math.max(leftInfo.max, max);
			min = Math.min(leftInfo.min, min);
			allSize += leftInfo.allSize;
		}
		if (rightInfo != null) {
    
			max = Math.max(rightInfo.max, max);
			min = Math.min(rightInfo.min, min);
			allSize += rightInfo.allSize;
		}
		int p1 = -1;
		if (leftInfo != null) {
    
			p1 = leftInfo.maxBSTSubtreeSize;
		}
		int p2 = -1;
		if (rightInfo != null) {
    
			p2 = rightInfo.maxBSTSubtreeSize;
		}
		int p3 = -1;
		boolean leftBST = leftInfo == null ? true : (leftInfo.maxBSTSubtreeSize == leftInfo.allSize);
		boolean rightBST = rightInfo == null ? true : (rightInfo.maxBSTSubtreeSize == rightInfo.allSize);
		if (leftBST && rightBST) {
    
			boolean leftMaxLessX = leftInfo == null ? true : (leftInfo.max < x.val);
			boolean rightMinMoreX = rightInfo == null ? true : (x.val < rightInfo.min);
			if (leftMaxLessX && rightMinMoreX) {
    
				int leftSize = leftInfo == null ? 0 : leftInfo.allSize;
				int rightSize = rightInfo == null ? 0 : rightInfo.allSize;
				p3 = leftSize + rightSize + 1;
			}
		}
		return new Info(Math.max(p1, Math.max(p2, p3)), allSize, max, min);
	}

}