二叉树相关问题

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

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

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

而后续因为要把左右孩子都遍历完了才能打印当前节点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->maxreturn 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); // importantreturn 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;}