算法-二叉树

二叉树

简单程度

1. 前序遍历 (上-左-右)

   class Solution {
       public List<Integer> preorderTraversal(TreeNode root) {
           List<Integer> res = new ArrayList<Integer>();
           preorder(root, res);
           return res;
       }
   ​
       public void preorder(TreeNode root, List<Integer> res) {
           if (root == null) {
               return;
           }
           res.add(root.val);
           preorder(root.left, res);
           preorder(root.right, res);
       }
   }

2. 中序遍历（左-上-右）

   inorder(root.left, res);
   res.add(root.val);
   inorder(root.right, res);

3. 后续遍历 （左-右-上）

   postorder(root.left, res);
   postorder(root.right, res);
   res.add(root.val);

4. 求二叉树的深度

   class Solution {
       public int maxDepth(TreeNode root) {
           if(root==null){
               return 0;
           }
           int left = maxDepth(root.left);
           int right = maxDepth(root.right);
           return Math.max(left,right)+1;
       }
   }

1. 求二叉树的最小深度 (分别计算其左右子树的最小叶子节点深度)

   class Solution {
       public int minDepth(TreeNode root) {
           if (root == null) {
               return 0;
           }
           if (root.left == null && root.right == null) {
               return 1;
           }
           int min_depth = Integer.MAX_VALUE;
           if (root.left != null) {
               min_depth = Math.min(minDepth(root.left), min_depth);
           }
           if (root.right != null) {
               min_depth = Math.min(minDepth(root.right), min_depth);
           }
           return min_depth + 1;
       }
   }

1. 翻转二叉树 (左右子树交换)

   class Solution {
       public TreeNode invertTree(TreeNode root) {
           if (root == null) {
               return null;
           }
           TreeNode left = invertTree(root.left);
           TreeNode right = invertTree(root.right);
           root.left = right;
           root.right = left;
           return root;
       }
   }

1. 输出二叉树的所有路径

   class Solution {
       public List<String> binaryTreePaths(TreeNode root) {
           List<String> paths = new ArrayList<String>();
           constructPaths(root, "", paths);
           return paths;
       }
       public void constructPaths(TreeNode root, String path, List<String> paths) {
           if (root != null) {
               StringBuffer pathSB = new StringBuffer(path);
               pathSB.append(Integer.toString(root.val));
               if (root.left == null && root.right == null) {  // 当前节点是叶子节点
                   paths.add(pathSB.toString());  // 把路径加入到答案中
               } else {
                   pathSB.append("->");  // 当前节点不是叶子节点，继续递归遍历
                   constructPaths(root.left, pathSB.toString(), paths);
                   constructPaths(root.right, pathSB.toString(), paths);
               }
           }
       }
   }
   //输入：[1,2,3,null,5]
   //输出:["1->2->5","1->3"]

1. 求二叉树的直径

   class Solution {
       int ans;
       public int diameterOfBinaryTree(TreeNode root) {
           ans = 1;
           depth(root);
           return ans - 1;
       }
       public int depth(TreeNode node) {
           if (node == null) {
               return 0; // 访问到空节点了，返回0
           }
           int L = depth(node.left); // 左儿子为根的子树的深度
           int R = depth(node.right); // 右儿子为根的子树的深度
           ans = Math.max(ans, L+R+1); // 计算d_node即L+R+1 并更新ans
           return Math.max(L, R) + 1; // 返回该节点为根的子树的深度
       }
   }
   //一棵二叉树的直径长度是任意两个结点路径长度中的最大值

1. 求二叉树的坡度

   class Solution {
       int ans = 0;
   ​
       public int findTilt(TreeNode root) {
           dfs(root);
           return ans;
       }
   ​
       public int dfs(TreeNode node) {
           if (node == null) {
               return 0;
           }
           int sumLeft = dfs(node.left);
           int sumRight = dfs(node.right);
           ans += Math.abs(sumLeft - sumRight);
           return sumLeft + sumRight + node.val;
       }
   }
   //节点的坡度: 定义即为，该节点左子树的节点之和和右子树节点之和的 差的绝对值 。如果没有左子树的话，左子树的节点之和为 0 ；没有右子树的话也是一样。空结点的坡度是 0 。
   //整个树的坡度: 就是其所有节点的坡度之和。

1. 根据二叉树创建字符串

   public class Solution {
       public String tree2str(TreeNode t) {
           if(t==null)
               return "";
           if(t.left==null && t.right==null)
               return t.val+"";
           if(t.right==null)
               return t.val+"("+tree2str(t.left)+")";
           return t.val+"("+tree2str(t.left)+")("+tree2str(t.right)+")";   
       }
   }
   输入: 二叉树: [1,2,3,4]
   输出: "1(2(4))(3)"
   解释: 原本将是“1(2(4)())(3())”，
   在你省略所有不必要的空括号对之后，
   它将是“1(2(4))(3)”。

2. 合并二叉树

   class Solution {
       public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
           if (t1 == null) {
               return t2;
           }
           if (t2 == null) {
               return t1;
           }
           TreeNode merged = new TreeNode(t1.val + t2.val);
           merged.left = mergeTrees(t1.left, t2.left);
           merged.right = mergeTrees(t1.right, t2.right);
           return merged;
       }
   }
   ​