2022-2-25 剑指offer day15

Posted 2022-02-25 阿ming

题1：

JZ84 二叉树中和为某一值的路径(三)

描述

给定一个二叉树root和一个整数值 sum ，求该树有多少路径的的节点值之和等于 sum 。

1.该题路径定义不需要从根节点开始，也不需要在叶子节点结束，但是一定是从父亲节点往下到孩子节点

2.总节点数目为n

3.保证最后返回的路径个数在整形范围内(即路径个数小于231-1)

 

数据范围:

0<=n<=10000<=n<=1000

-10^9<=节点值<=10^9−109<=节点值<=109

 

假如二叉树root为1,2,3,4,5,4,3,#,#,-1，sum=6，那么总共如下所示，有3条路径符合要求

 import java.util.*;
 
 /*
  * public class TreeNode 
  *   int val = 0;
  *   TreeNode left = null;
  *   TreeNode right = null;
  *   public TreeNode(int val) 
  *     this.val = val;
  *   
  * 
  */
 
 public class Solution 
     /**
      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
      *
      * 
      * @param root TreeNode类 
      * @param sum int整型 
      * @return int整型
      */
     int s=0;
     int ans;
     
     public int FindPath (TreeNode root, int sum) 
         // write code here
         int res=0;
         if (root==null) return res;
         Queue<TreeNode> queue=new LinkedList<>();
         queue.offer(root);
         while (!queue.isEmpty())
             TreeNode temp=queue.poll();
             ans=0;
             res+=FromThisToEnd(temp,sum);
             if (temp.left!=null) queue.offer(temp.left);
             if (temp.right!=null) queue.offer(temp.right);
             //System.out.println(temp.val);
         
         return res;
     
     
     
     public int FromThisToEnd(TreeNode root,int sum)
         if (root!=null) 
            s+=root.val;
            if (s==sum) ans++;
            FromThisToEnd(root.left,sum);
            FromThisToEnd(root.right,sum);
            s-=root.val;
         
         return ans;
     
 

思路：自定义函数计算当前节点满足条件的数量，遍历树的所有节点，累加结果。

 

题2：

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

 

描述

给定一棵二叉树(保证非空)以及这棵树上的两个节点对应的val值 o1 和 o2，请找到 o1 和 o2 的最近公共祖先节点。

 

数据范围：1 \\le n \\le 10001≤n≤1000，树上每个节点的val满足 0<val \\le 1000<val≤100

要求：时间复杂度 O(n)O(n)

 

注：本题保证二叉树中每个节点的val值均不相同。

 

如当输入[3,5,1,6,2,0,8,#,#,7,4],5,1时，二叉树3,5,1,6,2,0,8,#,#,7,4如下图所示：

所以节点值为5和节点值为1的节点的最近公共祖先节点的节点值为3，所以对应的输出为3。

节点本身可以视为自己的祖先

 import java.util.*;
 
 /*
  * public class TreeNode 
  *   int val = 0;
  *   TreeNode left = null;
  *   TreeNode right = null;
  * 
  */
 
 public class Solution 
     /**
      * 
      * @param root TreeNode类 
      * @param o1 int整型 
      * @param o2 int整型 
      * @return int整型
      */
     Map<Integer,Integer> map;
     public int lowestCommonAncestor (TreeNode root, int o1, int o2) 
         // write code here
         map=new HashMap<>();
         dfs(root);
         Set<Integer> set1=new HashSet<>();
         set1.add(o1);
         while (map.containsKey(o1)) 
             o1=map.get(o1);
             set1.add(o1);
         
         //for (int s:set1) System.out.print(s+" ");
         while (!set1.contains(o2))
             o2=map.get(o2);
         
         return o2;
     
     
     public void dfs(TreeNode root)
         if (root==null) return;
         if (root.left!=null) 
             map.put(root.left.val,root.val);
             dfs(root.left);
             //System.out.println(root.left.val+"->"+root.val);
         
         if (root.right!=null) 
             map.put(root.right.val,root.val);
             dfs(root.right);
             //System.out.println(root.right.val+"->"+root.val);
         
         
        
     
 

思路：遍历树，因为节点值不同，利用hashmap将节点的祖先存入map，遍历一个节点的所有祖先存入set，再遍历另外一个节点的祖先出现重复就是结果。注意，自己也是自己的祖先，所以要把自己也放入集合。