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]++;
        }
    }

 

posted @ 2018-09-11 21:37  BigJunOba  阅读(260)  评论(0编辑  收藏  举报