二叉树相关问题

前序，中序非递归比较容易

前序：先一直压左孩子，每次压栈的时候就打印，没有左孩子可压，就出栈，同时把右孩子压栈，继续一直压左孩子

中序：先一直压左孩子，没有左孩子可压，就出栈，出栈的时候打印，同时把右孩子压栈，继续一直压左孩子

而后续因为要把左右孩子都遍历完了才能打印当前节点node，而又不能通过node把左右孩子联系起来（前中序都有当前节点在栈中维持node.left，node.right的联系）

后续有2种办法：

（1）后续是左右中，我们先求中右左（稍微修改前序遍历），然后反过来输出，

（2）维护2个变量，保存栈顶node，之前打印的node，根据两者判断对当前节点打印到什么程度了（左孩子没打印？左孩子打印了，右孩子没有打印？左右孩子都打印了）

注意这里所说的子树是：如果选取了某个root节点，那root节点所有的孩子节点都要包括进去

这个题目的思想是：根据左右子树收集的信息，整合判断当前节点的信息，然后希望子树收集什么就递归调用

这里需要4个信息：

1. 树的max value

2. 树的min value

3. 最大搜索子树的头结点

4. 最大搜索子树的长度

当把左右子树的这8个信息收集上来了后，当前节点的这4个信息可以求得：

1. 树的max value：max(left_max, right_max)

2. 树的min value：min(left_min, right_min)

3. 先判断是否能把左右子树连起来组成更大的BST（left_BST_root_node==left && right_BST_root_node==right && lmax<value && rmin>value），如果可以就返回当前节点，否则就根据左右子树最大BST长度决定用那边

4. 见3

public class Problem_07_BiggestSubBSTInTree {

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

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

	public static Node biggestSubBST(Node head) {
		int[] record = new int[3]; // 0->size, 1->min, 2->max
		return posOrder(head, record);
	}

	public static Node posOrder(Node head, int[] record) {
		if (head == null) {
			record[0] = 0;
			record[1] = Integer.MAX_VALUE;
			record[2] = Integer.MIN_VALUE;
			return null;
		}
		int value = head.value;
		Node left = head.left;
		Node right = head.right;
		Node lBST = posOrder(left, record);
		int lSize = record[0];
		int lMin = record[1];
		int lMax = record[2];
		Node rBST = posOrder(right, record);
		int rSize = record[0];
		int rMin = record[1];
		int rMax = record[2];
		record[1] = Math.min(lMin, value);
		record[2] = Math.max(rMax, value);
		if (left == lBST && right == rBST && lMax < value && value < rMin) {
			record[0] = lSize + rSize + 1;
			return head;
		}
		record[0] = Math.max(lSize, rSize);
		return lSize > rSize ? lBST : rBST;
	}
}

记得之前自己在LC上做的是用个全局变量保存max，其实本质上也是从子树收集信息（子树的高度）

之前最开始的想法是：遍历树，遍历的时候决策：是不是把当前节点设置为路径的开始，然后全局保存一个max长度即可

But， it turns out it originates from a 算法原型：子数组累加和为target的最长长度

在那个算法原型用的是HasnTable，这里换成树也是类似的思路，也是遍历的时候累加，无非树需要回退到之前状态往其他子树遍历，那就同时把sum和HashTable回退就好了嘛

	public static int getMaxLength(Node head, int sum) {
		HashMap<Integer, Integer> sumMap = new HashMap<Integer, Integer>();
		sumMap.put(0, 0); // important
		return preOrder(head, sum, 0, 1, 0, sumMap);
	}

	public static int preOrder(Node head, int sum, int preSum, int level,
			int maxLen, HashMap<Integer, Integer> sumMap) {
		if (head == null) {
			return maxLen;
		}
		int curSum = preSum + head.value;
		if (!sumMap.containsKey(curSum)) {
			sumMap.put(curSum, level);
		}
		if (sumMap.containsKey(curSum - sum)) {
			maxLen = Math.max(level - sumMap.get(curSum - sum), maxLen);
		}
		maxLen = preOrder(head.left, sum, curSum, level + 1, maxLen, sumMap);
		maxLen = preOrder(head.right, sum, curSum, level + 1, maxLen, sumMap);
		if (level == sumMap.get(curSum)) {
			sumMap.remove(curSum);
		}
		return maxLen;
	}