引子：刷题的过程可能是枯燥的，但程序员们的日常确不乏趣味。分享一则LeetCode上名为《打家劫舍 |||》题目的评论：

如有兴趣可以从此题为起点，去LeetCode开启刷题之旅，哈哈。该题目是选择一颗二叉树中对应节点的问题，也是本文收录的一道例题（具体请参考例12）。

本文开始分享作者对于LeetCode上有关树的刷题总结。谈到树，很多初学者会感觉很头疼。头疼的重点是其很多解法都离不开递归（或者说是深度优先搜索）的应用。而递归的难点在于其有很多返回值，对于这些返回值的顺序很难理顺，即代码虽短，但理解很烧脑。因此，对递归思想理解不够深的同学，建议先看作者的另一篇文章《LeetCode刷题总结-递归篇》，然后再开启攻克有关树的相关习题之旅（PS：这样会起到事半功倍的效果噢）。

在LeetCode的标签分类题库中，和树有关的标签有：树（123道题）、字典树（17道题）、线段树（11道题）、树状数组（6道题）。对于这些题，作者在粗略刷过一遍后，对其中的考点进行了总结，并归纳为以下四大类：

      • 树的自身特性
      • 树的类型
      • 子树问题
      • 新概念定义问题

对于上述四类考点，作者通过分析对比同类型考点的题目，选取其中比较经典或者有代表性的题目作为例题（共计收录约45道题）。在减少题量的同时，也希望能够全面覆盖LeetCode上关于树的相关习题的考点。作者计划分为三篇文章来讲解，本文是该系列的上篇，讲解考察树的自身特性相关考点的习题。选取的例题共21道，其中简单题5道、中等题13道、困难题3道。

关于树的自身特性总结归纳为四个问题：基本特性问题、构造问题、节点问题和路径问题，具体如下图所示。

树基本特性问题：请参考下文例1至例8。

树的构造问题：请参考下文例9、例10。

树的节点问题：请参考下文例11至例16。

树的路径问题：请参考下文例17至例21。

对于上述四个问题，基本特性和构造问题只需刷过一遍即可理解相关解法。对于树的节点和路径问题，则是本文例题中的相对困难的习题，一般需要重复刷或者深度分析和琢磨，才能感悟普适解法的套路。其中，在有关树的路径问题中，本文未收录树的前、中、后和层次遍历问题的习题，这些题目默认为较为基础的习题。

例1 对称二叉树

题号：101，难度：简单

题目描述：

解题思路：

递归思想的一个简单应用，从以树的根节点的左右子节点为根开始进行深度优先搜索，依次判断两颗子树的左子树是否更与其右子树，右子树是否等于其左子树即可。如果采用迭代则只需使用层次遍历，判断每层元素是否满足镜像对称即可。

具体代码：

  1. class Solution {
  2.     public boolean isSymmetric(TreeNode root) {
  3.         if(root == null)
  4.             return true;
  5.         return dfs(root.left, root.right);
  6.     }
  7.  
  8.     public boolean dfs(TreeNode left, TreeNode right) {
  9.         if(left == null && right == null)
  10.             return true;
  11.         if(left == null || right == null || left.val != right.val)
  12.             return false;
  13.         return dfs(left.left, right.right) && dfs(left.right, right.left);
  14.     }
  15. } 

运行结果：

例2 翻转二叉树以匹配前序遍历

题号：971，难度：中等（关于翻转类习题，还可以参考题号226和951）

题目描述：

解题思路：

该题也是递归思想的应用。按照题目要求进行前序遍历，一旦遇到对应值与目标数组结果不同时，翻转遍历，接着继续遍历，如果最终结果依然不匹配则返回false，否则返回true。

具体代码：

  1. class Solution {
  2.     private int index;
  3.     private int[] voyage;
  4.     private List<Integer> result;
  5.  
  6.     public List<Integer> flipMatchVoyage(TreeNode root, int[] voyage) {
  7.         // index = 0;
  8.         this.voyage = voyage;
  9.         result = new ArrayList<>();
  10.         dfs(root);
  11.         // System.out.println("result = "+result);
  12.         if(result.size() > 0 && result.get(result.size()-1) == -1)
  13.             return new ArrayList<Integer>(Arrays.asList(-1));
  14.         return result;
  15.     }
  16.  
  17.     public void dfs(TreeNode root) {
  18.         if(root == null)
  19.             return;
  20.         if(root.val != voyage[index++])
  21.             result.add(-1);
  22.         else {
  23.             if(root.left != null && root.left.val != voyage[index]) {
  24.                 result.add(root.val);
  25.                 dfs(root.right);
  26.                 dfs(root.left);
  27.             } else {
  28.                 dfs(root.left);
  29.                 dfs(root.right);
  30.             }
  31.         }
  32.     }
  33. }

运行结果：

例3 输出二叉树

题号：655，难度：中等

题目描述：

解题思路：

此题是要求以二维数组的形式画出给定的二叉树。需要建立一个以根节点为原点的平面直角坐标系，然后依据广度优先搜索（即层次遍历）的思想依次初始化每层数组中元素的值即可，其中应用到了二分查找来确定每个元素的具体坐标，能够有效降低检索时间。

具体代码：

  1. class Solution {
  2.     public List<List<String>> printTree(TreeNode root) {
  3.         List<List<String>> result = new ArrayList<>();
  4.         int dep = getDepth(root);
  5.         Queue<TreeNode> queue = new LinkedList<>();
  6.         queue.add(root);
  7.         // System.out.println("dep = "+dep);
  8.         for(int i = 0;i < dep;i++) {
  9.             List<String> list = new ArrayList<>();
  10.             for(int j = 0;j < Math.pow(2, dep)-1;j++)
  11.                 list.add("");
  12.             List<Integer> index = new ArrayList<>();
  13.             getIndex(i, 0, list.size() - 1, index);
  14.             for(int j = 0;j < Math.pow(2, i);j++) {
  15.                 TreeNode temp = queue.poll();
  16.                 if(temp == null) {
  17.                     queue.add(temp);
  18.                     queue.add(temp);
  19.                 } else {
  20.                     list.set(index.get(j), ""+temp.val);
  21.                     queue.add(temp.left);
  22.                     queue.add(temp.right);
  23.                 }
  24.             }
  25.             result.add(list);
  26.         }
  27.         return result;
  28.     }
  29.  
  30.     public int getDepth(TreeNode root) {
  31.         if(root == null)
  32.             return 0;
  33.         return 1 + Math.max(getDepth(root.left), getDepth(root.right));
  34.     }
  35.  
  36.     public void getIndex(int num, int left, int right, List<Integer> index) {
  37.         int mid = (left + right) / 2;
  38.         if(num == 0)
  39.             index.add(mid);
  40.         else {
  41.             getIndex(num - 1, left, mid - 1, index);
  42.             getIndex(num - 1, mid + 1, right, index);
  43.         }
  44.     }
  45. } 

运行结果：

例4 合并二叉树

题号：617，难度：简单

题目描述：

解题思路：

此题比较简单，选取其中一个根节点作为返回值的根节点。然后应用深度优先搜索的思想，采用相同顺序同时遍历两棵树，如果当前节点均存在则相加，否则则选取含有值的节点。

具体代码：

  1. class Solution {
  2.     public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
  3.         if(t1 == null)
  4.             return t2;
  5.         else if(t2 == null)
  6.             return t1;
  7.         t1.left = mergeTrees(t1.left, t2.left);
  8.         t1.right = mergeTrees(t1.right, t2.right);
  9.         t1.val = t1.val + t2.val;
  10.  
  11.         return t1;
  12.     }
  13. }

运行结果:

例5 二叉树剪枝

题号：814，难度：中等（另外，还可以参考题号669，修剪二叉搜索树）

题目描述：

解题思路：

此题属于二叉树节点删除问题的实际应用，并且结合深度优先搜索（前序遍历的应用）和回溯的思想。具体实现过程请参考下方代码。

具体代码：

  1. class Solution {
  2.     public TreeNode pruneTree(TreeNode root) {
  3.         if(root == null)
  4.             return root;
  5.         if(root.val == 0 && root.left == null && root.right == null)
  6.             root = root.left;
  7.         else {
  8.             root.left = pruneTree(root.left);
  9.             root.right = pruneTree(root.right);
  10.         }   
  11.  
  12.         if(root != null && root.val == 0 && root.left == null && root.right == null)
  13.             root = root.left;
  14.  
  15.         return root;
  16.     }
  17. } 

运行结果：

例6 二叉树的右视图

题号：199，难度：中等

题目描述：

解题思路：

层次遍历的实际应用。只需依次保存每层最右边的一个节点即可。

具体代码：

  1. class Solution {
  2.     public List<Integer> rightSideView(TreeNode root) {
  3.         if(root == null)
  4.             return new ArrayList<Integer>();
  5.         Queue<TreeNode> queue = new LinkedList<>();
  6.         queue.offer(root);
  7.         List<Integer> result = new ArrayList<>();
  8.         while(queue.size() > 0) {
  9.             int count = queue.size();
  10.             while(count-- > 0) {
  11.                 TreeNode temp = queue.poll();
  12.                 if(count == 0)
  13.                     result.add(temp.val);
  14.                 if(temp.left != null)
  15.                     queue.offer(temp.left);
  16.                 if(temp.right != null)
  17.                     queue.offer(temp.right);
  18.             }
  19.         }
  20.  
  21.         return result;
  22.     }
  23. } 

运行结果：

例7 二叉树的最小深度

题号：111，难度：简单（最大深度请参考题号：104）

题目描述：

解题思路：

深度优先搜索的应用，代码很简洁，这个思想可以借鉴。

具体代码：

  1. class Solution {
  2.     public int minDepth(TreeNode root) {
  3.         if(root == null)
  4.             return 0;
  5.         if(root.left != null && root.right != null)
  6.             return 1 + Math.min(minDepth(root.left), minDepth(root.right));
  7.         else
  8.             return 1 + minDepth(root.right) + minDepth(root.left);
  9.     }
  10. }

运行结果：

例8 二叉树的最大宽度

题号：662，难度：中等（另外，可参考题号：543，二叉树的直径）

题目描述：

解题思路：

层次遍历的实际应用，依次更新每层最大宽度即可。

具体代码：

  1. class Solution {
  2.     public int widthOfBinaryTree(TreeNode root) {
  3.         if(root == null)
  4.             return 0;
  5.         int result = 0;
  6.         Queue<TreeNode> queue = new LinkedList<>();
  7.         Queue<Integer> index = new LinkedList<>();
  8.         queue.offer(root);
  9.         index.offer(1);
  10.         while(queue.size() > 0) {
  11.             int count = queue.size();
  12.             int left = index.peek();
  13.             // System.out.println("left = "+left+", count = "+count);
  14.             while(count-- > 0) {
  15.                 TreeNode temp = queue.poll();
  16.                 int i = index.poll();
  17.                 if(temp.left != null) {
  18.                     queue.offer(temp.left);
  19.                     index.offer(i * 2);
  20.                 }
  21.                 if(temp.right != null) {
  22.                     queue.offer(temp.right);
  23.                     index.offer(i * 2 + 1);
  24.                 }
  25.                 if(count == 0)
  26.                     result = Math.max(result, 1 + i - left);
  27.             }
  28.         }
  29.         return result;
  30.     }
  31. }

运行结果：

例9 依据前序和后序遍历构造二叉树

题号：889，难度：中等（另外，可参考同类型习题，题号：105，106，1008）

题目描述：

解题思路：

可以先手动构造画以下，体会其中的构造规则，然后采用深度优先搜索的思想来实现。每次找到当前子树的根节点，并确定左右子树的长度，并不断递归遍历构造即可。

具体代码：

  1. class Solution {
  2.     private int[] pre;
  3.     private int[] post;
  4.     private Map<Integer, Integer> map;
  5.  
  6.     public TreeNode constructFromPrePost(int[] pre, int[] post) {
  7.         this.pre = pre;
  8.         this.post = post;
  9.         map = new HashMap<>();
  10.         for(int i = 0;i < post.length;i++)
  11.             map.put(post[i], i);
  12.  
  13.         return dfs(0, pre.length-1, 0, post.length-1);
  14.     }
  15.  
  16.     public TreeNode dfs(int pre_left, int pre_right, int post_left, int post_right) {
  17.         if(pre_left > pre_right || post_left > post_right)
  18.             return null;
  19.         TreeNode root = new TreeNode(pre[pre_left]);
  20.         int len = 0;
  21.         if(pre_left + 1 < pre_right)
  22.             len = map.get(pre[pre_left+1]) - post_left;
  23.         root.left = dfs(pre_left+1, pre_left+1+len < pre_right ? pre_left+1+len: pre_right, post_left, post_left+len);
  24.         root.right = dfs(pre_left+len+2, pre_right, post_left+len+1, post_right-1);
  25.  
  26.         return root;
  27.     }
  28. }

运行结果：

例10 从先序遍历还原二叉树

题号：1028，难度：困难

题目描述：

解题思路：

定义一个全局变量用于确定当前深度优先遍历元素处在左子树还是右子树，能够有效减少代码量，并提高代码的可阅读性。

具体代码：

  1. class Solution {
  2.     int i = 0;  // 神来之笔， 定义全局变量i，可以有效区分左子树和右子树
  3.  
  4.     public TreeNode recoverFromPreorder(String s) {
  5.         return buildtree(s,0);
  6.     }
  7.  
  8.     public TreeNode buildtree(String s,int depth){
  9.         if(i == s.length()) return null;
  10.         TreeNode cur = null;
  11.         int begin = i;
  12.         while(s.charAt(begin) == '-')  begin ++;
  13.         int end = begin;
  14.         while(end < s.length() && s.charAt(end) - '0' >= 0 && s.charAt(end) - '0' < 10) end ++;
  15.         if(begin - i == depth){
  16.             cur = new TreeNode(Integer.valueOf(s.substring(begin,end)));
  17.             i = end;
  18.         }
  19.         if(cur != null){
  20.             // System.out.println("dep = "+depth+", cur = "+cur.val);
  21.             cur.left = buildtree(s,depth + 1);
  22.             cur.right = buildtree(s,depth + 1); // 通过全局变量i，可以在同一层深度找到右子树
  23.         }
  24.         return cur;
  25.     }
  26. }

运行结果：

例11 二叉树的最近公共祖先

题号：236，难度：中等

题目描述：

解题思路：

此题一道和经典的面试题，代码量很少，但是对于很多初学者来说比较难以理解。采用深度优先搜索的思想，搜索目标节点。具体解题思路请参考代码。

具体代码：

  1. class Solution {
  2.     public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
  3.         // LCA 问题
  4.         if (root == null) {
  5.             return root;
  6.         }
  7.         if (root == p || root == q) {
  8.             return root;
  9.         }
  10.         TreeNode left = lowestCommonAncestor(root.left, p, q);
  11.         TreeNode right = lowestCommonAncestor(root.right, p, q);
  12.         if (left != null && right != null) {
  13.             return root;
  14.         } else if (left != null) {
  15.             return left;
  16.         } else if (right != null) {
  17.             return right;
  18.         }
  19.         return null;
  20.     }
  21. }

运行结果：

例12 打家劫舍 III

题号：337，难度：中等

题目描述：

解题思路：

本题考察后序遍历思想的应用，感觉外加了一点动态规划的思维。题目要求是寻找一个想加和较大的节点集。具体实现思路请参考代码。

具体代码：

  1. class Solution {
  2.  
  3.     public int rob(TreeNode root) {
  4.         return postorder(root);
  5.     }
  6.  
  7.     public int postorder(TreeNode root){
  8.         if(root == null)
  9.             return 0;
  10.         postorder(root.left);
  11.         postorder(root.right);
  12.         int res1 = 0;  // 左右
  13.         int res2 = root.val;  //根
  14.         if (root.left != null){
  15.             res1 += root.left.val;
  16.             if (root.left.left != null)
  17.                 res2 += root.left.left.val;
  18.             if (root.left.right != null)
  19.                 res2 += root.left.right.val;
  20.         }
  21.         if (root.right != null){
  22.             res1 += root.right.val;
  23.             if (root.right.left != null)
  24.                 res2 += root.right.left.val;
  25.             if (root.right.right!=null)
  26.                 res2 += root.right.right.val;
  27.         }
  28.         root.val = Math.max(res1, res2);
  29.         return root.val;
  30.     }
  31. }

运行结果：

例13 在二叉树中增加一行

题号：623，难度：中等

题目描述：

解题思路：

此题考察二叉树的添加节点的问题。并且保持原有节点的相对顺序不断，具体解题思路可参考代码。

具体代码：

  1. class Solution {
  2.    public TreeNode addOneRow(TreeNode root, int v, int d) {
  3.      if (d == 0 || d == 1) {
  4.          TreeNode t = new TreeNode(v);
  5.          if (d == 1) t.left = root;
  6.          else t.right = root;
  7.          return t;
  8.      }
  9.      if (root != null && d > 1) {
  10.          root.left = addOneRow(root.left, v, d > 2 ? d - 1 : 1);
  11.          root.right = addOneRow(root.right, v, d > 2 ? d - 1 : 0);
  12.      }
  13.      return root;
  14.   }
  15. }

运行结果：

例14 二叉树中所有距离为K的节点

题号：863，难度：中等

题目描述：

解题思路：

保存从根节点开始到叶子节点的每个路径，然后找到目标节点的位置，按照距离大小采用哈希定位的思想找到对应节点。

具体代码：

  1. class Solution {
  2.     private Map<TreeNode,String>map=new HashMap<>();
  3.     private String path;
  4.  
  5.     public List<Integer> distanceK(TreeNode root, TreeNode target, int K) {
  6.         List<Integer>list=new ArrayList<>();
  7.         getNodeDist(root,target,"");
  8.         int i;
  9.         for(TreeNode key:map.keySet()){
  10.             String s=map.get(key);
  11.             for(i=0;i<s.length()&&i<path.length()&&s.charAt(i)==path.charAt(i);i++);
  12.             if(s.length()-i+path.length()-i==K)
  13.                 list.add(key.val);
  14.         }
  15.         return list;
  16.     }
  17.  
  18.     public void getNodeDist(TreeNode root,TreeNode target,String p){
  19.             if(root != null){
  20.                 path = root == target ? p : path;
  21.                 map.put(root, p);
  22.                 getNodeDist(root.left,target,p+"0");
  23.                 getNodeDist(root.right,target,p+"1");
  24.             }
  25.     }
  26. } 

运行结果：

例15 监控二叉树

题号：968，难度：困难

题目描述：

解题思路：

此题也是选取一个符合题目要求的节点子集，但是取的要求是间隔化取点，并且需要满足数量最小。具体实现可参考下方代码。

具体代码：

  1. class Solution {
  2.     private int ans = 0;
  3.  
  4.     public int minCameraCover(TreeNode root) {
  5.         if (root == null) return 0;
  6.         if (dfs(root) == 2) ans++;
  7.         return ans;
  8.     }
  9.  
  10.     // 1：该节点安装了监视器 2：该节点可观，但没有安装监视器 3：该节点不可观
  11.     private int dfs(TreeNode node) {
  12.         if (node == null)
  13.             return 1;
  14.         int left = dfs(node.left), right = dfs(node.right);
  15.         if (left == 2 || right == 2) {
  16.             ans++;
  17.             return 0;
  18.         } else if (left == 0 || right == 0){
  19.             return 1;
  20.         } else
  21.             return 2;
  22.     }
  23. }

运行结果：

例16 二叉树着色游戏

题号：1145，难度：中等

题目描述：

解题思路：

此题也是一道节点选择的问题，但是涉及到了博弈论。按照题目的要求我们会发现选择一个节点后正常情况下会把整棵树分为三个部分，只需要获胜者能够访问的一部分节点个数大于另一方即可确保最终获胜。

具体代码：

  1. class Solution {
  2.    //极客1选的起始点有多少个左节点
  3.     private int left = 0;
  4.     //极客1选的起始点有多少个右节点
  5.     private int right = 0;
  6.  
  7.     public boolean btreeGameWinningMove(TreeNode root, int n, int x) {
  8.         //极客1选了第一个节点后，将树划分为了三个部分（可能为空）
  9.         //第一部分：left 第二部分：right 第三部分：n - (left + right) - 1
  10.         //只需要总结点的数的一半 < 三个部分中的最大值，极客2就可以获胜
  11.         return getNum(root, x) / 2 < Math.max(Math.max(left, right), n - (left + right) - 1);
  12.     }
  13.  
  14.     private int getNum(TreeNode node, int x) {
  15.         if (node == null) {
  16.             return 0;
  17.         }
  18.         int r = getNum(node.right, x);
  19.         int l = getNum(node.left, x);
  20.         if (node.val == x) {
  21.             left = l;
  22.             right = r;
  23.         }
  24.         return l + r + 1;
  25.     }
  26. }

运行结果:

例17 二叉树的所有路径

题号：257，难度：简单

题目描述：

解题思路：

此题是路径选择的一个基本习题，是解决路径相关问题的必须掌握的一道题。采用深度优先搜索保存每条路径即可。

具体代码：

  1. class Solution {
  2.  
  3.     public List<String> binaryTreePaths(TreeNode root) {
  4.         List<String> ret = new ArrayList<>();
  5.         if(root==null)
  6.             return ret;
  7.         solve(root, "", ret);
  8.         return ret;
  9.     }
  10.  
  11.     public void solve(TreeNode root, String cur, List<String> ret){
  12.         if(root==null)
  13.             return;
  14.         cur += root.val;
  15.         if(root.left == null && root.right == null) {
  16.             ret.add(cur);
  17.         } else {
  18.             solve(root.left, cur+"->", ret);
  19.             solve(root.right, cur+"->", ret);
  20.         }
  21.     }
  22. }

运行结果：

例18 二叉树中分配硬币

题号：979，难度：中等

题目描述：

解题思路：

本题考察我们采用前序遍历，并抽象为本题解答的过程。具体原理请参考代码。

具体代码：

  1. class Solution {
  2.     /**
  3.      * 从后序遍历的第一个叶子节点开始，假设自己有x个金币，剩余x-1个金币都还给父节点，x-1可能为负数、0、正数
  4.      * x-1 < 0说明不够金币，需要从父节点获得，因此子节点有|x-1|个入方向的操作，次数加上|x-1|
  5.      * x-1 == 0说明刚好，无需与父节点有金币的交换，次数加0
  6.      * x-1 > 0 说明有多余的金币，需要交给父节点，因此子节点有x-1个出方向的操作，次数加上|x-1|
  7.      */
  8.     private int ans = 0;// 移动次数
  9.     public int distributeCoins(TreeNode root) {
  10.         lrd(root);
  11.         return ans;
  12.     }
  13.     public int lrd(TreeNode root){
  14.         if(root == null){
  15.             return 0;
  16.         }
  17.         if(root.left != null){
  18.             root.val += lrd(root.left);
  19.         }
  20.         if(root.right != null){
  21.             root.val += lrd(root.right);
  22.         }
  23.         ans += Math.abs(root.val - 1);
  24.         return root.val - 1;
  25.     }
  26. }

运行结果：

例19 二叉树的垂序遍历

题号：987，难度：中等

题目描述：

解题思路：

通过给每个节点定制编号的思路，采用前序遍历的思想来完成本题要求的垂序遍历。

具体代码：

  1. class Solution {
  2.     private Map<Integer, List<List<Integer>>> map = new HashMap<>();
  3.     private int depth;
  4.  
  5.     public List<List<Integer>> verticalTraversal(TreeNode root) {
  6.         depth = getDepth(root);
  7.         dfs(root, 0, 0);
  8.         List<List<Integer>> result = new ArrayList<>();
  9.         int min = 0;
  10.         for(Integer key: map.keySet()){
  11.             min = Math.min(min, key);
  12.             result.add(new ArrayList<Integer>());
  13.         }
  14.         for(Integer key: map.keySet()){
  15.             for(int i = 0;i < depth;i++) {
  16.                 List<Integer> temp = map.get(key).get(i);
  17.                 if(temp.size() == 1)
  18.                     result.get(key-min).add(temp.get(0));
  19.                 else if(temp.size() > 1) {  // 同层同列的元素，按照从小到大排序
  20.                     Collections.sort(temp);
  21.                     for(Integer t: temp)
  22.                         result.get(key-min).add(t);
  23.                 }
  24.             }
  25.         }
  26.         return result;
  27.     }
  28.  
  29.     public int getDepth(TreeNode root) {
  30.         if(root == null)
  31.             return 0;
  32.         return 1 + Math.max(getDepth(root.left), getDepth(root.right));
  33.     }
  34.  
  35.     public void dfs(TreeNode root, int x, int y) {
  36.         if(root == null)
  37.             return;
  38.         List<List<Integer>> temp;
  39.         if(map.containsKey(x))
  40.             temp = map.get(x);
  41.         else {
  42.             temp = new ArrayList<>();
  43.             for(int i = 0;i < depth;i++)
  44.                 temp.add(new ArrayList<Integer>());
  45.         }
  46.         temp.get(y).add(root.val);
  47.         map.put(x, temp);
  48.         dfs(root.left, x-1, y+1);
  49.         dfs(root.right, x+1, y+1);
  50.     }
  51. } 

运行结果：

例20 二叉树中的最大路径和

题号：124，难度：困难

题目描述：

解题思路：

这道题的解题思路和例11 二叉树的最近公共祖先比较相似，都是采用深度优先搜索的思想，并分别寻找左右子树的结果，最后和根节点进行比较。具体实现的思路请参考下方代码。

具体代码：

  1. class Solution {
  2.  
  3.     private int ret = Integer.MIN_VALUE;
  4.  
  5.     public int maxPathSum(TreeNode root) {
  6.         /**
  7.         对于任意一个节点, 如果最大和路径包含该节点, 那么只可能是两种情况:
  8.         1. 其左右子树中所构成的和路径值较大的那个加上该节点的值后向父节点回溯构成最大路径
  9.         2. 左右子树都在最大路径中, 加上该节点的值构成了最终的最大路径
  10.         **/
  11.         getMax(root);
  12.         return ret;
  13.     }
  14.  
  15.     private int getMax(TreeNode r) {
  16.         if(r == null) return 0;
  17.         int left = Math.max(0, getMax(r.left)); // 如果子树路径和为负则应当置0表示最大路径不包含子树
  18.         int right = Math.max(0, getMax(r.right));
  19.         ret = Math.max(ret, r.val + left + right); // 判断在该节点包含左右子树的路径和是否大于当前最大路径和
  20.         return Math.max(left, right) + r.val;
  21.     }
  22. }

运行结果：

例21 路径总和 |||

题号：437，难度：简单

题目描述：

解题思路：

首先，此题并不简单。其次，本题是二叉树路径问题中一个很有代表性的问题。采用前序遍历的思想，以及根节点和子树的关系，不断更新最终结果。

具体代码：

  1. class Solution {
  2.     int pathnumber;
  3.     public int pathSum(TreeNode root, int sum) {
  4.             if(root == null) return 0;
  5.             Sum(root,sum);
  6.             pathSum(root.left,sum);
  7.             pathSum(root.right,sum);
  8.             return pathnumber;
  9.         }
  10.  
  11.     public void Sum(TreeNode root, int sum){
  12.         if(root == null) return;
  13.         sum-=root.val;
  14.         if(sum == 0){
  15.             pathnumber++;
  16.         }
  17.         Sum(root.left,sum);
  18.         Sum(root.right,sum);
  19.     }
  20. } 

运行结果：

LeetCode刷题总结-树篇（上）的更多相关文章

  1. LeetCode刷题总结-树篇（下）

    本文讲解有关树的习题中子树问题和新概念定义问题,也是有关树习题的最后一篇总结.前两篇请参考: LeetCode刷题总结-树篇(上) LeetCode刷题总结-树篇(中) 本文共收录9道题,7道中等题, ...

  2. LeetCode刷题总结-树篇（中）

    本篇接着<LeetCode刷题总结-树篇(上)>,讲解有关树的类型相关考点的习题,本期共收录17道题,1道简单题,10道中等题,6道困难题. 在LeetCode题库中,考察到的不同种类的树 ...

  3. LeetCode刷题总结-数组篇（中）

    本文接着上一篇文章<LeetCode刷题总结-数组篇(上)>,继续讲第二个常考问题:矩阵问题. 矩阵也可以称为二维数组.在LeetCode相关习题中,作者总结发现主要考点有:矩阵元素的遍历 ...

  4. LeetCode刷题总结-数组篇（上）

    数组是算法中最常用的一种数据结构,也是面试中最常考的考点.在LeetCode题库中,标记为数组类型的习题到目前为止,已累计到了202题.然而,这202道习题并不是每道题只标记为数组一个考点,大部分习题 ...

  5. LeetCode刷题总结-数组篇（下）

    本期讲O(n)类型问题,共14题.3道简单题,9道中等题,2道困难题.数组篇共归纳总结了50题,本篇是数组篇的最后一篇.其他三个篇章可参考: LeetCode刷题总结-数组篇(上),子数组问题(共17 ...

  6. LeetCode刷题专栏第一篇--思维导图&时间安排

    昨天是元宵节,过完元宵节相当于这个年正式过完了.不知道大家有没有投入继续投入紧张的学习工作中.年前我想开一个Leetcode刷题专栏,于是发了一个投票想了解大家的需求征集意见.投票于2019年2月1日 ...

  7. C#LeetCode刷题-字典树

    字典树篇 # 题名 刷题 通过率 难度 208 实现 Trie (前缀树)   48.6% 中等 211 添加与搜索单词 - 数据结构设计   39.9% 中等 212 单词搜索 II   27.9% ...

  8. LeetCode刷题总结-字符串篇

    本文梳理对LeetCode上有关字符串习题的知识点,并给出对应的刷题建议.本文建议刷题的总数为32题.具体知识点如下图: 1.回文问题 题号:5. 最长回文子串,难度中等 题号:214. 最短回文串, ...

  9. C#LeetCode刷题-线段树

    线段树篇 # 题名 刷题 通过率 难度 218 天际线问题   32.7% 困难 307 区域和检索 - 数组可修改   42.3% 中等 315 计算右侧小于当前元素的个数   31.9% 困难 4 ...

随机推荐

  1. Redis系列（二）：Redis高可用集群

    一.集群模式 Redis集群是一个由多个主从节点组成的高可用集群,它具有复制.高可用和分片等特性 二.集群部署 1.环境 3台主机分别是: 192.168.160.146 192.168.160.15 ...

  2. php 打印数组格式化显示

    输出前添加 <pre>,便可以自动格式化换行显示. print_r("<pre>"); 比如打印数组 : print_r($arr); 输出: Array ...

  3. 防范XSS攻击

    原文链接:http://www.cnblogs.com/chenty/p/5136834.html 最近,有个项目突然接到总部的安全漏洞报告,查看后知道是XSS攻击. 问题描述: 在页面上有个隐藏域: ...

  4. easywechat微信开发SDK之小微商户进件（一）

    微信本身不提供小微商户进件的SDK,偶然发现easywechat这么个东西,官网地址是https://www.easywechat.com/  整合了微信开发中常用的接口,包括微信公众号相关接口,微信 ...

  5. day20191120笔记

    1.spring的优势 U盘拷.总结.微信公众号:.2.笔试,课前默写,默完之后要回答问题.3.微服务,带着,知识点,卷子.ssm整个东西讲一下.面试是综合能力.背面试题. 通过基础很重要.学精烂熟于 ...

  6. myql数据库，sql横排转竖排以及竖排转横排，oracle的over函数的使用

    一.引言 前些日子遇到了一个sql语句的横排转竖排以及竖排转横排的问题,现在该总结一下,具体问题如下: 这里的第二题和第三题和下面所讲述的学生的成绩表是相同的,这里给大家留一下一个念想,大家可以自己做 ...

  7. 【Android - 组件】之IntentFilter的匹配规则

    我们知道,Activity的启动模式分为两种,分别是显式启动和隐式启动.显式启动需要明确的指定被启动的对象的组件信息,包括包名和类名:而隐式启动需要 Intent 能够匹配目标组件的 IntentFi ...

  8. Win10无法安装.NET Framework3.5的解决办法

    诸位网友如果工作中使用WIN10遇到如图的这种问题,现将解决办法整理如下: 一.第一步就是修复系统:按“Windows+X”点击“Windows PowerShell(管理员)&命令提示符(管 ...

  9. Docker 构建私有仓库

    Docker Hub 目前Docker官方维护了一个公共仓库Docker Hub,其中已经包含了数量超过15000的镜像.大部分需求都可以通过在Docker Hub中直接下载镜像来实现. 可以在htt ...

  10. 新一代数据安全的制胜法宝-UBA

    [摘要]在入侵防御领域,运用数据分析的方法保护数据的技术其实没有什么新的东西,比如防火墙-分析数据包的内容以及其他的元数据,如IP地址,从增长的数据条目中检测和阻断攻击者:防病毒软件不断的扫描文件系统 ...