第二周作业#001

Week_01/id_1/LeetCode_101_1.java

@@ -0,0 +1,61 @@
+package week01;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/10  11:47
+ * @描述      LeetCode : 101. 对称二叉树   https://leetcode-cn.com/problems/symmetric-tree/
+ */
+public class SymmetricTree101 {
+
+    public static void main(String[] args) {
+        TreeNode node = new TreeNode(1);
+        node.left=new TreeNode(2);
+        node.right=new TreeNode(2);
+        node.left.left=new TreeNode(3);
+        node.left.right=new TreeNode(4);
+        node.right.left=new TreeNode(4);
+        node.right.right=new TreeNode(4);
+        System.out.println(new SymmetricTree101().isSymmetric2(node));
+    }
+
+    /**
+     *  Method 1 : 迭代 BFS —> 把每一层的节点都放在队列中，树的左子树 和 右子树 比较是否相等；
+     *  时间复杂度 ： O(N) 树的节点  ；    空间复杂度 ： O(N) 额外的空间队列；
+     *
+     */
+    public boolean isSymmetric(TreeNode root) {
+        Queue<TreeNode> nodes = new LinkedList<>();
+        nodes.offer(root);
+        nodes.offer(root);
+        while (!nodes.isEmpty()){
+             TreeNode n1 = nodes.poll();
+             TreeNode n2 = nodes.poll();
+             if(n1 ==null && n2==null) continue;
+             if(n1==null || n2 ==null) return false;
+             if(n1.val!=n2.val) return false;
+            nodes.offer(n1.left);
+            nodes.offer(n2.right);
+            nodes.offer(n1.right);
+            nodes.offer(n2.left);
+        }
+        return true;
+    }
+
+    /**
+     *  Method 2 : 递归 DFS —>    操作同一棵树两次，树的左子树 和 右子树 比较；
+     *  时间复杂度 ： O(N)    ；   空间复杂度 ： O(N)    ；
+     */
+    public boolean isSymmetric2(TreeNode root) {
+        return isMirrer(root,root);
+    }
+
+    private boolean isMirrer(TreeNode n1,TreeNode n2) {
+        if(n1==null&& n2==null) return true;
+        if(n1==null || n2==null) return false;
+        if(n1.val!=n2.val)  return false;
+        return isMirrer(n1.left,n2.right)&& isMirrer(n1.right,n2.left);
+    }
+}

Week_01/id_1/LeetCode_104_1.java

@@ -0,0 +1,53 @@
+package week01;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/10  10:08
+ * @描述 LeetCode : 104. 二叉树的最大深度    https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/
+ */
+public class MaximumDepthBinaryTree104 {
+
+    public static void main(String[] args) {
+
+    }
+
+    /**
+     * Method 1: 递归  DFS —> 分别计算 左右节点的最大深度 ，比较 max ，然后加上 根节点 +1；
+     * 时间复杂度： O(N) ；   空间复杂度： O(N)
+     */
+    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;
+    }
+
+    /**
+     * Method 2 : 迭代 BFS 的思想 ——> 用队列来存储 树的节点
+     * 时间复杂度： O(N) 树的遍历 ;   空间复杂度：  O(N)  额外的空间：队列   ;
+     */
+    public int maxDepth2(TreeNode root) {
+        if (root == null) return 0;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        int depth = 0;
+        int size = 1;
+        while (!queue.isEmpty()) {
+            TreeNode node = queue.poll();
+            if (node.left != null) queue.offer(node.left);
+            if (node.right != null) queue.offer(node.right);
+            size--;
+            if (size == 0) {
+                depth++;
+                size = queue.size();
+            }
+        }
+        return depth;
+    }
+
+}

Week_01/id_1/LeetCode_111_1.java

@@ -0,0 +1,58 @@
+package week01;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/10  10:13
+ * @描述      LeetCode :  111. 二叉树的最小深度   https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/
+ */
+public class MinimumDepthBinaryTree111 {
+    public static void main(String[] args) {
+        final MinimumDepthBinaryTree111 tree111 = new MinimumDepthBinaryTree111();
+
+    }
+
+    /**
+     * Method 1:  递归 分别求左右节点的最小深度；
+     * 考虑情况 ：
+     * 1： 左节点为空,只需要计算右节点的最小深度，即 right+1
+     * 2： 右节点为空,只需要计算左节点的最小深度，即 left+1
+     * 时间复杂度：O(N) ;   空间复杂度：O(N)
+     */
+    public int minDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        final int left = minDepth(root.left);
+        final int right = minDepth(root.right);
+        if (left == 0 || right == 0) {
+            return left + right + 1;
+        }
+        return Math.min(left, right) + 1;
+    }
+
+    /**
+     * Method 2 : 迭代 BFS 思想 —> 把 树的节点加入到 队列当中进行出来，当节点没有左节点和右节点时，返回当前深度即为最小深度
+     */
+    public int minDepth2(TreeNode root) {
+        if (root == null) return 0;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        int depth = 1;
+        int size = 1;
+        while (!queue.isEmpty()) {
+            TreeNode node = queue.poll();
+            if (node.left != null) queue.offer(node.left);
+            if (node.right != null) queue.offer(node.right);
+            if (node.left == null && node.right == null) return depth;
+            size--;
+            if (size == 0) {
+                depth++;
+                size = queue.size();
+            }
+        }
+        return depth;
+    }
+}

Week_01/id_1/LeetCode_236_1.java

@@ -0,0 +1,34 @@
+package week01;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/10  18:33
+ * @描述 LeetCode : 236. 二叉树的最近公共祖先      https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/
+ */
+public class LowestCommonAncestor236 {
+    public static void main(String[] args) {
+        TreeNode node = new TreeNode(3);
+        node.left = new TreeNode(5);
+        node.right = new TreeNode(2);
+        node.left.left = new TreeNode(6);
+        node.left.right = new TreeNode(2);
+        node.left.right.left = new TreeNode(7);
+        node.left.right.right = new TreeNode(4);
+
+        node.right.left = new TreeNode(0);
+        node.right.right = new TreeNode(8);
+        System.out.println(new LowestCommonAncestor236().lowestCommonAncestor(node, node.left, node.left.right.right).toString());
+    }
+
+    /**
+     * Method 1 : 递归 ； 分别从  根的左子树 和 右子树 分别查找；
+     * 时间复杂度 ： O(N)    ;   空间复杂度 : O(2N)   ;
+     */
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null || root == p || root == q) return root;
+        TreeNode left = lowestCommonAncestor(root.left, p, q);
+        TreeNode right = lowestCommonAncestor(root.right, p, q);
+        if (left != null && right != null) return root;
+        return left != null ? left : right;
+    }
+}

Week_01/id_1/LeetCode_257_1.java

@@ -0,0 +1,41 @@
+package week01;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/10  15:37
+ * @描述 LeetCode : 257. 二叉树的所有路径        https://leetcode-cn.com/problems/binary-tree-paths/
+ */
+public class BinaryTreePaths257 {
+    public static void main(String[] args) {
+        TreeNode node = new TreeNode(4);
+        node.left = new TreeNode(2);
+        node.right = new TreeNode(6);
+        node.left.left = new TreeNode(1);
+        node.left.right = new TreeNode(3);
+        System.out.println(new BinaryTreePaths257().binaryTreePaths(node));
+    }
+
+    /**
+     * Method 1 : DFS  先左子树 ，再右子树
+     * 时间复杂度 : O(N)  树的所有节点全部遍历一遍 ;   空间复杂度 ： O(N)    额外的开销 字符串
+     */
+    public List<String> binaryTreePaths(TreeNode root) {
+        List<String> list = new ArrayList<>();
+        dfs(root, list, "");
+        return list;
+    }
+
+    private void dfs(TreeNode root, List list, String str) {
+        if (root == null) return;
+        if (root.left == null && root.right == null) {
+            list.add(str += root.val);
+            return;
+        } else {
+            dfs(root.left, list, str + root.val + "->");
+            dfs(root.right, list, str + root.val + "->");
+        }
+    }
+}

Week_01/id_1/LeetCode_783_1.java

@@ -0,0 +1,43 @@
+package week01;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/10  14:38
+ * @描述 LeetCode : 783. 二叉搜索树结点最小距离     https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/
+ */
+public class MinimumdistanceBetweenBstNodes783 {
+
+    int min = Integer.MAX_VALUE;
+    TreeNode pre = null;
+
+    public static void main(String[] args) {
+        TreeNode node = new TreeNode(4);
+        node.left = new TreeNode(2);
+        node.right = new TreeNode(6);
+        node.left.left = new TreeNode(1);
+        node.left.right = new TreeNode(3);
+        System.out.println(new MinimumdistanceBetweenBstNodes783().minDiffInBST(node));
+    }
+
+    /**
+     *
+     * Method 1 : 递归 中序遍历的方法；   先计算左边的相邻节点的最小差，在计算右边相邻节点的最小差
+     *  时间复杂度 ： O(N)    ;   空间复杂度： O(1) ;
+     */
+    public int minDiffInBST(TreeNode root) {
+        dfs(root);
+        return min;
+    }
+
+    private void dfs(TreeNode root) {
+        // 终止条件
+        if (root == null) return ;
+        //要做的事情     // 先求 左边的两节点的最小差
+        dfs(root.left);
+        if (pre != null) min = Math.min(root.val - pre.val, min);
+        pre = root;
+        //要做的事情     // 先求 右边的两节点的最小差
+        dfs(root.right);
+    }
+
+}

Week_01/id_1/LeetCode_938_1.java

@@ -0,0 +1,41 @@
+package week01;
+
+/**
+ * @创建人 luoxiang
+ * @创建时间 2019/6/10  16:38
+ * @描述      LeetCode :  938. 二叉搜索树的范围和      https://leetcode-cn.com/problems/range-sum-of-bst/
+ */
+public class RangeSumBst938 {
+    public static void main(String[] args) {
+        TreeNode node = new TreeNode(10);
+        node.left = new TreeNode(5);
+        node.right = new TreeNode(15);
+        node.left.left = new TreeNode(3);
+        node.left.right = new TreeNode(7);
+        node.right.right = new TreeNode(18);
+        System.out.println(new RangeSumBst938().rangeSumBST(node,7,15));
+    }
+
+    /**
+     *  Method 1 : DFS  递归中直接操作数据
+     *   时间复杂度 ： O(N)   ;   空间复杂度 ： O(N)    ;
+     */
+    public int rangeSumBST(TreeNode root, int L, int R) {
+        return dfs(root,L,R);
+    }
+
+    private int dfs(TreeNode root, int l, int r) {
+        if(root==null){
+            return 0;
+        }
+        if(root.val<l ){
+            return dfs(root.right,l,r);
+        }
+        if(root.val>r){
+            return dfs(root.left,l,r);
+        }
+        return root.val+dfs(root.left,l,r)+dfs(root.right,l,r);
+    }
+
+
+}