OptimalSolution(2)--二叉树问题（3）Path路径问题

　　一、在二叉树中找到累加和为指定值的最长路径长度

　　给定一棵二叉树和一个32位整数sum，求累加和为sum的最长路径长度。路径是指从某个节点往下，每次最多选择一个孩子节点或者不选所形成的节点链

              -3
            /    \
           3      -9
          /  \    / \
         1    0  2   1
              /\               如果sum=6，那么累加和为6的最长路径为：-3,3,0,6，所以返回4
             1  6              如果sum=-9，那么累加和为-9的最长路径为：-9，所以返回1

　　第一步：生成变量maxLen，记录累加和等于sum的最长路径长度

　　第二步：生成哈希表sumMap，负责记录从根结点root开始的一条路径上的累加和出现情况。sumMap的key值代表某个累加和，value值代表这个累加和在路径中最早出现的层数。如果在遍历到cur节点的时候，已经知道了从root到cur节点这条路径上的累加和出现情况，那么求以cur节点结尾的累加和为指定值的最长路径长度就非常容易。那么问题是，如何去更新sumMap，才能够做到在遍历到任何一个节点的时候都能有从root到这个节点的路径上的累加和出现情况？

　　第三步：首先在sumMap中加入一个记录(0,0)，表示累加和0不用包括任何节点就可以得到。然后先序遍历节点，遍历到的当前节点记为cur，从root到cur父节点的累加和记为preSum，cur所在的层数记为level，将cur.val+preSum值记为curSum，就是从root到cur的累加和。如果sumMap中已经包含了curSum的记录，说明curSum在上层已经出现过，那么就不更新sumMap；如果sumMap不包含curSum的记录，说明curSum是第一次出现，就把（curSum，level）这个记录放入sumMap。在以cur为头节点的子树处理完，在返回cur父节点之前，还需要在sumMap中查询curSum这个累加和（key）出现的层数（value），如果value等于level，说明curSum这个累加和的记录是在遍历到cur时加上去的，那么就把这条记录删除，如果value不等于level，则不做任何调整。

　　分析执行过程：

0.{0=0}，curSum=0，
1.-3，{0=0, -3=1}，curSum=-3，
2.-3 → 3，{0=0, -3=1}，curSum=0，
3.-3 → 3 → 1，{0=0, 1=3, -3=1}，curSum=1，
4.-3 → 3，{0=0, -3=1}，curSum=0，
5.-3 → 3 → 0，{0=0, -3=1}，curSum=0，
6.-3 → 3 → 0 → 1，{0=0, 1=4, -3=1}，curSum=1，
7.-3 → 3 → 0， {0=0, -3=1}，curSum=0，
8.-3 → 3 → 0 → 6， {0=0, -3=1, 6=4}，curSum=6，
9.-3 → 3 → 0，{0=0, -3=1}，curSum=0，
10.-3 → 3，{0=0, -3=1}，curSum=0，
11.-3 ，{0=0, -3=1}，curSum=0，
12.-3 → -9，{0=0, -3=1, -12=2}，curSum=-12，
13.-3 → -9 → 2，{0=0, -3=1, -10=3, -12=2}，curSum=-10，
14.-3 → -9 ，{0=0, -3=1, -12=2}，curSum=-12，
15.-3 → -9 → 1，{0=0, -3=1, -11=3, -12=2}，curSum=-11，
16.-3 → -9 ，{0=0, -3=1, -12=2}，curSum=-12，
17.-3 ，{0=0, -3=1}，curSum=-3，
18.{0=0，curSum=0，

　　情况1：sum=6，根据 if ( sumMap.containsKey(curSum - sum)) { maxLen = Math.max(level - sumMap.get(curSum - sum), maxLen); }在上面的第8步，curSum-sum=0，maxLen=0，level-sumMap.get(curSum - sum)=4-0=0，因此maxLen=4。

　　情况2：sum=-8，在上面的第15步，curSum=-11，而curSum-sum=-3，level-sumMap.get(curSum - sum)=3-1=2，因此maxLen=2,这里的意思就是，从根节点出发累加和为-11的时候需要走3level，而根据sumMap中的-3=1可以知道，从根节点出发累加和为-3的时候只需要走1level，因此要想实现累加和为-8只需要从1level走到3level即可。

　　代码实现：

    public int getMaxLength(Node root, int sum) {
        // key表示某个累加和，value表示这个累加和在路径中最早出现的层数
        HashMap<Integer, Integer> sumMap = new HashMap<>();
        // 表示累加和0不用经过任何节点就可以得到
        sumMap.put(0, 0);
        return preOrder(root, sum, 0, 1, 0, sumMap);
    }

    /**
     * @param root        遍历到当前节点，记为cur
     * @param sum        要求的累加和
     * @param preSum    从整棵树的根节点root到cur的父节点累加和
     * @param level        cur所在的层数
     * @param sumMap    记录累加和与该累加和在路径中最早出现的层数
     * @return maxLen    累加和等于sum的最长路径长度
     */
    private int preOrder(Node root, int sum, int preSum, int level, int maxLen, HashMap<Integer, Integer> sumMap) {
        if (root == null) return maxLen;
        // 从root到cur的累加和等于从root到cur的父节点的累加和加上cur的val
        int curSum = preSum + root.val;
        // 如果sumMap不包含这个累加和，说明是第一次出现，就加入到sumMap中
        if (!sumMap.containsKey(curSum)) sumMap.put(curSum, level);
        // 如果curSum - sum已经包含了，就说明之前已经有了从根节点到达curSum - sum需要的level数，因此，
        // 用从根节点到当前节点的level数减去从根节点到curSum - sum需要的level数就是从curSum - sum节点走到当前curSum节点的level数
        // 也就是，curSum - (curSum - sum) = sum
        if ( sumMap.containsKey(curSum - sum)) {
            maxLen = Math.max(level - sumMap.get(curSum - sum), maxLen);
        }
        maxLen = preOrder(root.left,  sum, curSum, level + 1, maxLen, sumMap);
        maxLen = preOrder(root.right, sum, curSum, level + 1, maxLen, sumMap);
        // 如果curSum这个累加和的记录是在遍历到cur时加上去的，那么在返回cur的父节点之前需要删除这个记录，
        // 否则就不是从cur的父节点到cur的父节点的其他子节点，而是从cur到cur的兄弟节点
        if (level == sumMap.get(curSum)) sumMap.remove(curSum);
        return maxLen;
    }

　　二、在二叉树中找到两个节点的最近公共祖先

　　1.给定一棵二叉树以及这棵树的两个节点o1和o2，返回o1和o2的最近公共祖先节点。

               1
            /    \
           2       3
          /  \    / \
         4    5  6   7
                     /
                    8         4和5的最近公共祖先为2,5和2的最近公共祖先为2,6和8的最近公共祖先为3,5和8的最近公共祖先为1

　　解法：后序遍历二叉树，假设遍历到的当前节点为cur，因为后序遍历要先处理cur的两棵子树，假设处理cur左子树时返回节点为left，处理右子树时返回节点为right

　　（1）如果cur等于null或者o1或者o2，返回cur

　　（2）如果left和right都为空，说明cur整棵子树上都没有发现过o1和o2，返回null

　　（3）如果left和right都不为空，说明左子树上发现过o1或o2，右子树上也发现过o2或o1，说明o1向上与o2向上的过程中，首次在cur相遇，返回cur

　　（4）如果left和right有一个为空，有一个不为空，假设不为空的节点记为node，此时有两种可能，要么node是o1或o2中的一个，要么node已经是o1和o2的最近公共祖先，两种情况下，都可以返回node。

　　执行过程是：

假设o1=6，o2=8
依次遍历4,5,2都没有发现o1或o2，所以1的左子树返回null
遍历6，发现等于o1，返回6，所以3的左子树返回6
遍历8，发现等于o2，返回8，所以7的左子树返回8
结点7的右子树为null，而左子树为8，所以返回8
遍历3，左子树返回6，右子树返回8，此时返回3
遍历1，左子树返回null，右子树返回3，因此返回3

　　代码实现：

    public Node lowestAncestor(Node root, Node o1, Node o2) {
        // 情况1：root为null时返回null，情况2：root为o1或者o2本身时，返回root
        if (root == null || root == o1 || root == o2) return root;
        Node left  = lowestAncestor(root.left, o1, o2);
        Node right = lowestAncestor(root.right, o1, o2);
        // 情况3，在左子树发现了o1或o2，在右子树发现了o1或o2，那么最近公共祖先一定是root，返回root
        if (left != null && right != null) return root;
        // 情况4，left和right如果都为null，那么返回null
        // 情况5：left和right有且只有一个不为null，那么返回不为null的那个
        return left != null ? left : right;
    }

　　2.

　　3.　　

　　三、求二叉树节点间的最大距离

　　问题：从二叉树的节点A出发，沿途的节点只能经过一次，当到达节点B时，路径上的节点数叫做A到B的距离，包括A和B本身。

　　思路：一个以root为根节点的树，最大距离只能来自以下三种情况：（1）root的左子树上的最大距离（2）root的右子树上的最大距离（3）root左子树上例root.left最远的距离 + 1 + root的右子树上离root.right最远的距离

　　解法：1.整个过程为后序遍历。2.假设子树根节点为root，处理root左子树，得到两个信息，左子树上的最大距离记为lMax，左子树上距离root左孩子的最远距离记为maxfromLeft。同理，右子树上最大距离为rMax，右子树上距离root右孩子最远距离记为maxFromRight。那么maxFromLeft + 1 + maxFromRight就是跨root节点的最大距离，再与lMax和rMax比较，把三者中最大值作为root树上最大距离返回，maxFromLeft+1就是root左子树上离root最远的点到root的距离，maxFromRight+1就是root右子树上离root最远的点到root的距离，选两者中最大的一个作为root树上距离root最远的距离返回。

　　执行过程是：

               1
            /    \
           2       3
          /       /4       6     
遍历4，lMax=0，record[0]=0，rMax=0，record[0]=0，curNodeMax=1，record[0]=1，返回1
遍历2，lMax=1，record[0]=1，rMax=0，record[0]=0，curNodeMax=2，record[0]=2，返回2
遍历6，lMax=0，record[0]=0，rMax=0，record[0]=0，curNodeMax=1，record[0]=1，返回1
遍历3，lMax=1，record[0]=1，rMax=0，record[0]=0，curNodeMax=2，record[0]=2，返回2
遍历1，lMax=2，record[0]=2，rMax=2，record[0]=2，curNOdeMax=5，record[0]=3，返回5，结束

　　代码实现：

    public int maxDistance(Node root) {
        int[] record = new int[1];
        return postOrder(root, record);
    }

    public int postOrder(Node root, int[] record) {
        if (root == null) {
            record[0] = 0;
            return 0;
        }
        int lMax = postOrder(root.left , record);                　　// 左子树上两点最远距离
        int maxFromLeft  = record[0];                            　　// 到root.left最远距离
        int rMax = postOrder(root.right, record);                　　// 右子树上两点最远距离
        int maxFromRight = record[0];                            　　// 到root.right最远距离
        int curNodeMax = maxFromLeft + 1 + maxFromRight;        　　 // 经过root的最远距离
        record[0] = Math.max(maxFromLeft, maxFromRight) + 1;    　　 // 到root的最远距离
        return Math.max(Math.max(lMax, rMax), curNodeMax);          // 返回以root为根节点的树的两节点的最大距离
    }

　　四、求根节点到叶节点的路径

              -3
            /    \
           3      -9
          /  \    / \
         1    0  2   1
              /\              1  6              输出：[-3->3->1, -3->3->0->1, -3->3->0->6, -3->-9->2, -3->-9->1]

　　分析过程：前序遍历，使用两个全局变量List<String> res, String str，其中res作为结果集list，str作为字符串。

1.""开始
2.-3->，遍历到-3
3.-3->3，遍历到3
4.-3->3->1->，遍历到1，打印
5.-3->3->0->1->遍历到1，打印
6.-3->3->0->6->遍历到6，打印
7.-3->3->0->遍历回到0
8.-3->3->遍历回到3
9.-3->-9->2->遍历到2，打印
10.-3->-9->1->遍历到1，打印
11.-3->-9->遍历回到-9
12.-3->遍历回到-3
13."" 结束

　　代码实现：

    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();
        preOrder(root, res, "");
        return res;
    }

    private void preOrder(TreeNode root, List<String> res, String str) {
        if (root == null) return ;
        str += root.val + "->";
        preOrder(root.left , res, str);
        preOrder(root.right, res, str);
        if (root.left == null && root.right == null) {
            str = str.substring(0, str.length() - 2);
            res.add(str);
        }
    }

　　变体：求是否存在从根节点到叶节点的节点和等于给定的值sum的路径

    public boolean hasPathSum(TreeNode root, int sum) {
        boolean[] res = new boolean[1];
        preOrder(root, sum, 0, res);
        return res[0];
    }

    private void preOrder(TreeNode root, int sum, int tmp, boolean[] res) {
        if (root == null) return;
        tmp += root.val;
        preOrder(root.left,  sum, tmp, res);
        preOrder(root.right, sum, tmp, res);
        if (root.left == null && root.right == null && tmp == sum) {
            res[0] = true;
            return ;
        }
    }

　　变体：求一棵树上从上到下的路径数，这个路径满足节点的累加和等于给定值sum（需要注意pathSum还要自循环）

    public int pathSum(TreeNode root, int sum) {
        if (root == null) return 0;
        int[] count = new int[1];
        preOrder(root, sum, 0, count);
        return count[0] + pathSum(root.left, sum) + pathSum(root.right, sum);
    }

    private void preOrder(TreeNode root, int sum, int tmp, int[] count) {
        if (root == null) return ;
        tmp += root.val;
        preOrder(root.left , sum, tmp, count);
        preOrder(root.right, sum, tmp, count);
        if (tmp == sum) {
            count[0]++;
        }
    }