From 6baed98599bfedcb1d27b8c93317cdce66fd517a Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Wed, 12 Jun 2019 14:24:39 +0800 Subject: [PATCH 01/26] =?UTF-8?q?LeetCode=20:=20257.=20=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=A0=91=E7=9A=84=E6=89=80=E6=9C=89=E8=B7=AF=E5=BE=84.=20https?= =?UTF-8?q?://leetcode-cn.com/problems/binary-tree-paths/?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_01/id_1/LeetCode_257_1.java | 41 ++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 Week_01/id_1/LeetCode_257_1.java diff --git a/Week_01/id_1/LeetCode_257_1.java b/Week_01/id_1/LeetCode_257_1.java new file mode 100644 index 00000000..b41779e3 --- /dev/null +++ b/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 binaryTreePaths(TreeNode root) { + List 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 + "->"); + } + } +} From 454db317b716b0c2e94cbcf27b45b0184e5c7de5 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Wed, 12 Jun 2019 14:25:41 +0800 Subject: [PATCH 02/26] =?UTF-8?q?LeetCode=20:=20236.=20=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=A0=91=E7=9A=84=E6=9C=80=E8=BF=91=E5=85=AC=E5=85=B1=E7=A5=96?= =?UTF-8?q?=E5=85=88=20=20=20=20=20=20https://leetcode-cn.com/problems/low?= =?UTF-8?q?est-common-ancestor-of-a-binary-tree/?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_01/id_1/LeetCode_236_1.java | 34 ++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 Week_01/id_1/LeetCode_236_1.java diff --git a/Week_01/id_1/LeetCode_236_1.java b/Week_01/id_1/LeetCode_236_1.java new file mode 100644 index 00000000..aa6218ba --- /dev/null +++ b/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; + } +} From eb9469ada80d0a3652db4789c1ccd4b11ad926fb Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Wed, 12 Jun 2019 14:26:39 +0800 Subject: [PATCH 03/26] =?UTF-8?q?LeetCode=20:=20104.=20=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=A0=91=E7=9A=84=E6=9C=80=E5=A4=A7=E6=B7=B1=E5=BA=A6=20=20=20?= =?UTF-8?q?=20https://leetcode-cn.com/problems/maximum-depth-of-binary-tre?= =?UTF-8?q?e/?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_01/id_1/LeetCode_104_1.java | 53 ++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 Week_01/id_1/LeetCode_104_1.java diff --git a/Week_01/id_1/LeetCode_104_1.java b/Week_01/id_1/LeetCode_104_1.java new file mode 100644 index 00000000..5569de43 --- /dev/null +++ b/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 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; + } + +} From 30ca8f690ed807ed1e03f142f0aa6f1f8f0d31c9 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Wed, 12 Jun 2019 14:28:59 +0800 Subject: [PATCH 04/26] =?UTF-8?q?LeetCode=20:=20=20111.=20=E4=BA=8C?= =?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E6=9C=80=E5=B0=8F=E6=B7=B1=E5=BA=A6?= =?UTF-8?q?=20=20=20https://leetcode-cn.com/problems/minimum-depth-of-bina?= =?UTF-8?q?ry-tree/?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_01/id_1/LeetCode_111_1.java | 58 ++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 Week_01/id_1/LeetCode_111_1.java diff --git a/Week_01/id_1/LeetCode_111_1.java b/Week_01/id_1/LeetCode_111_1.java new file mode 100644 index 00000000..d3b19102 --- /dev/null +++ b/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 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; + } +} From f0a29ad905da6c0eb4de67b1a5807b4f266d6c5d Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Wed, 12 Jun 2019 14:29:34 +0800 Subject: [PATCH 05/26] =?UTF-8?q?LeetCode=20:=20783.=20=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=90=9C=E7=B4=A2=E6=A0=91=E7=BB=93=E7=82=B9=E6=9C=80=E5=B0=8F?= =?UTF-8?q?=E8=B7=9D=E7=A6=BB=20=20=20=20=20https://leetcode-cn.com/proble?= =?UTF-8?q?ms/minimum-distance-between-bst-nodes/?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_01/id_1/LeetCode_783_1.java | 43 ++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 Week_01/id_1/LeetCode_783_1.java diff --git a/Week_01/id_1/LeetCode_783_1.java b/Week_01/id_1/LeetCode_783_1.java new file mode 100644 index 00000000..022b26d2 --- /dev/null +++ b/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); + } + +} From 3e4fc611dea08192a64799a4be2152b355d6712d Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Wed, 12 Jun 2019 14:30:07 +0800 Subject: [PATCH 06/26] =?UTF-8?q?LeetCode=20:=20=20938.=20=E4=BA=8C?= =?UTF-8?q?=E5=8F=89=E6=90=9C=E7=B4=A2=E6=A0=91=E7=9A=84=E8=8C=83=E5=9B=B4?= =?UTF-8?q?=E5=92=8C=20=20=20=20=20=20https://leetcode-cn.com/problems/ran?= =?UTF-8?q?ge-sum-of-bst/?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_01/id_1/LeetCode_938_1.java | 41 ++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 Week_01/id_1/LeetCode_938_1.java diff --git a/Week_01/id_1/LeetCode_938_1.java b/Week_01/id_1/LeetCode_938_1.java new file mode 100644 index 00000000..107612b0 --- /dev/null +++ b/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.valr){ + return dfs(root.left,l,r); + } + return root.val+dfs(root.left,l,r)+dfs(root.right,l,r); + } + + +} From d5f7f35c6fbe1cdd0f15c81b60221a5006ae8dc4 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Wed, 12 Jun 2019 14:30:51 +0800 Subject: [PATCH 07/26] =?UTF-8?q?LeetCode=20:=20101.=20=E5=AF=B9=E7=A7=B0?= =?UTF-8?q?=E4=BA=8C=E5=8F=89=E6=A0=91=20=20=20https://leetcode-cn.com/pro?= =?UTF-8?q?blems/symmetric-tree/?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_01/id_1/LeetCode_101_1.java | 61 ++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 Week_01/id_1/LeetCode_101_1.java diff --git a/Week_01/id_1/LeetCode_101_1.java b/Week_01/id_1/LeetCode_101_1.java new file mode 100644 index 00000000..e1528949 --- /dev/null +++ b/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 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); + } +} From d1fa72553fcff18d26ff5627ef1fc56efdc39c20 Mon Sep 17 00:00:00 2001 From: AALuoXiang Date: Fri, 14 Jun 2019 18:52:09 +0800 Subject: [PATCH 08/26] finished 14 --- .../BinaryTreeLevelorderTraversal102.java | 57 ++++++++ ...inaryTreeZigzagLevelOrderTraversal103.java | 87 +++++++++++ ...tSubstringWithoutRepeatingCharacters3.java | 136 ++++++++++++++++++ ...westCommonAncestorBinarySearchTree235.java | 70 +++++++++ .../LowestCommonAncestorBinaryTree236.java | 35 +++++ .../MinimumDistanceBetweenBstNodes783.java | 65 +++++++++ Week_02/id_1/MinimunDepthBinaryTree111.java | 67 +++++++++ Week_02/id_1/NumberOfAtoms726.java | 69 +++++++++ Week_02/id_1/README.MD | 39 +++++ Week_02/id_1/RangeSumBst938.java | 61 ++++++++ Week_02/id_1/SymmetricTree101.java | 84 +++++++++++ Week_02/id_1/TopKFrequentWords692.java | 68 +++++++++ Week_02/id_1/TreeNode.java | 22 +++ Week_02/id_1/TwoSum1.java | 51 +++++++ Week_02/id_1/ValidAnagram242.java | 53 +++++++ Week_02/id_1/ValidateBinarySearchTree98.java | 84 +++++++++++ 16 files changed, 1048 insertions(+) create mode 100644 Week_02/id_1/BinaryTreeLevelorderTraversal102.java create mode 100644 Week_02/id_1/BinaryTreeZigzagLevelOrderTraversal103.java create mode 100644 Week_02/id_1/LongestSubstringWithoutRepeatingCharacters3.java create mode 100644 Week_02/id_1/LowestCommonAncestorBinarySearchTree235.java create mode 100644 Week_02/id_1/LowestCommonAncestorBinaryTree236.java create mode 100644 Week_02/id_1/MinimumDistanceBetweenBstNodes783.java create mode 100644 Week_02/id_1/MinimunDepthBinaryTree111.java create mode 100644 Week_02/id_1/NumberOfAtoms726.java create mode 100644 Week_02/id_1/README.MD create mode 100644 Week_02/id_1/RangeSumBst938.java create mode 100644 Week_02/id_1/SymmetricTree101.java create mode 100644 Week_02/id_1/TopKFrequentWords692.java create mode 100644 Week_02/id_1/TreeNode.java create mode 100644 Week_02/id_1/TwoSum1.java create mode 100644 Week_02/id_1/ValidAnagram242.java create mode 100644 Week_02/id_1/ValidateBinarySearchTree98.java diff --git a/Week_02/id_1/BinaryTreeLevelorderTraversal102.java b/Week_02/id_1/BinaryTreeLevelorderTraversal102.java new file mode 100644 index 00000000..5a4d4da1 --- /dev/null +++ b/Week_02/id_1/BinaryTreeLevelorderTraversal102.java @@ -0,0 +1,57 @@ +package week02; + +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/14 16:24 + * @描述 LeetCode : 102. 二叉树的层次遍历 https://leetcode-cn.com/problems/binary-tree-level-order-traversal/ + */ +public class BinaryTreeLevelorderTraversal102 { + public static void main(String[] args) { + TreeNode node = new TreeNode(3); + node.left = new TreeNode(5); + node.right = new TreeNode(1); + 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); + final List> list = new BinaryTreeLevelorderTraversal102().levelOrder(node); + for (List integers : list) { + for (Integer integer : integers) { + System.out.print(integer + ","); + } + System.out.println(); + } + } + + /** + * Method 1 : BFS ，队列存储每一层的值, 用 currentSize 记录当前层的数量，currentSize 为0时，当前层遍历完毕 + * 时间复杂度 : O(N) 树的遍历 ; 空间复杂度 ： O(N) ; 额外的空间 队列 + */ + public List> levelOrder(TreeNode root) { + List> list = new LinkedList<>(); + if (root == null) return list; + Queue queue = new LinkedList<>(); + queue.offer(root); + int currentSize = 1; + List currentList = new LinkedList<>(); + while (!queue.isEmpty()) { + TreeNode node = queue.poll(); + currentList.add(node.val); + if (node.left != null) queue.offer(node.left); + if (node.right != null) queue.offer(node.right); + if (--currentSize == 0) { + currentSize = queue.size(); + list.add(currentList); + currentList = new LinkedList<>(); + } + } + return list; + } +} diff --git a/Week_02/id_1/BinaryTreeZigzagLevelOrderTraversal103.java b/Week_02/id_1/BinaryTreeZigzagLevelOrderTraversal103.java new file mode 100644 index 00000000..caa8a0e8 --- /dev/null +++ b/Week_02/id_1/BinaryTreeZigzagLevelOrderTraversal103.java @@ -0,0 +1,87 @@ +package week02; + +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/14 16:41 + * @描述 LeetCode : 103. 二叉树的锯齿形层次遍历 https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/ + */ +public class BinaryTreeZigzagLevelOrderTraversal103 { + public static void main(String[] args) { + TreeNode node = new TreeNode(3); + node.left = new TreeNode(5); + node.right = new TreeNode(1); + 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); + final List> list = new BinaryTreeZigzagLevelOrderTraversal103().zigzagLevelOrder(node); + for (List integers : list) { + for (Integer integer : integers) { + System.out.print(integer + ","); + } + System.out.println(); + } + } + + /** + * Method 1 : 对 准备新插入 List 进行处理，用一个奇偶数 或 布尔值 来记录是否需要反转 + * 时间复杂度 ： O(N) 树的遍历 + * 空间复杂度 : O(N) 额外空间 队列 + * + */ + public List> zigzagLevelOrder(TreeNode root) { + List> list = new LinkedList<>(); + if (root == null) return list; + Queue queue = new LinkedList<>(); + queue.offer(root); + int currentSize = 1; + int depth =0; + List currentList = new LinkedList<>(); + while (!queue.isEmpty()) { + TreeNode node = queue.poll(); + currentList.add(node.val); + if (node.left != null) queue.offer(node.left); + if (node.right != null) queue.offer(node.right); + if (--currentSize == 0) { + currentSize = queue.size(); + if(depth%2!=0) Collections.reverse(currentList); + list.add(currentList); + currentList = new LinkedList<>(); + depth++; + } + } + return list; + } + + public List> zigzagLevelOrder2(TreeNode root) { + List> list = new LinkedList<>(); + if (root == null) return list; + Queue queue = new LinkedList<>(); + queue.offer(root); + int currentSize = 1; + boolean depth =false; + List currentList = new LinkedList<>(); + while (!queue.isEmpty()) { + TreeNode node = queue.poll(); + currentList.add(node.val); + if (node.left != null) queue.offer(node.left); + if (node.right != null) queue.offer(node.right); + if (--currentSize == 0) { + currentSize = queue.size(); + if(depth) Collections.reverse(currentList); + list.add(currentList); + currentList = new LinkedList<>(); + depth=!depth; + } + } + return list; + } +} diff --git a/Week_02/id_1/LongestSubstringWithoutRepeatingCharacters3.java b/Week_02/id_1/LongestSubstringWithoutRepeatingCharacters3.java new file mode 100644 index 00000000..73e107ef --- /dev/null +++ b/Week_02/id_1/LongestSubstringWithoutRepeatingCharacters3.java @@ -0,0 +1,136 @@ +package week02; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/11 14:40 + * @描述 LeetCode : 3. 无重复字符的最长子串 https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/ + */ +public class LongestSubstringWithoutRepeatingCharacters3 { + public static void main(String[] args) { + System.out.println(new LongestSubstringWithoutRepeatingCharacters3().lengthOfLongestSubstring4("abcabcbb")); + System.out.println(new LongestSubstringWithoutRepeatingCharacters3().lengthOfLongestSubstring4("bbbbb")); + System.out.println(new LongestSubstringWithoutRepeatingCharacters3().lengthOfLongestSubstring4("pwwkew")); + System.out.println(new LongestSubstringWithoutRepeatingCharacters3().lengthOfLongestSubstring4(" ")); + System.out.println(new LongestSubstringWithoutRepeatingCharacters3().lengthOfLongestSubstring4("")); + System.out.println(new LongestSubstringWithoutRepeatingCharacters3().lengthOfLongestSubstring4("c")); + System.out.println(new LongestSubstringWithoutRepeatingCharacters3().lengthOfLongestSubstring4("abc")); + System.out.println(new LongestSubstringWithoutRepeatingCharacters3().lengthOfLongestSubstring4("abba")); + } + + /** + * Method 1 : 暴力法 + */ + public int lengthOfLongestSubstring1(String s) { + int max=0; + for(int i=0;i set = new HashSet<>(); + for(int i=start;i set = new HashSet<>(); + while (i map = new HashMap<>(); + int max=0; + int count=0; + for(int j=0;j root.val) return lowestCommonAncestor(root.right, p, q); + if (Math.max(p.val, q.val) < root.val) return lowestCommonAncestor(root.left, p, q); + return root; + } + + /** + * Method 2: 也可以不利用二叉搜索树的特性， 从左、右子树中都找一遍，比较费时 + * 也就是二叉树 的 最近公共祖先 + * 时间复杂度 ： O(N) ; + * 空间复杂度 : O(2N) ; + */ + public TreeNode lowestCommonAncestor2(TreeNode root, TreeNode p, TreeNode q) { + if (root == null || root == p || root == q) return root; + final TreeNode left = lowestCommonAncestor2(root.left, p, q); + final TreeNode right = lowestCommonAncestor2(root.right, p, q); + if (left != null && right != null) return root; + return left != null ? left : right; + } + + /** + * Method 3 : 利用二叉树的特性 ； 不使用 递归 实现 ； + * 还是分两边的情况处理 : 同时在 左边 或者 同时在右边 ， + * 同时在左边 ： root.val - p.val > 0 ; root.val - q.val > 0 ; root=root.left + * 同时在右边 ： root.val - p.val < 0 ; root.val - q.val < 0 ; root=root.right + * 它们 结果的乘积 一定是 大于 0 + * 不然的话直接返回当前的root了 + * 时间复杂度 : O(logN) 每次都是进行二分 ; + * 空间复杂度 ： O(1) ; 没有额外的空间开销 + */ + public TreeNode lowestCommonAncestor3(TreeNode root, TreeNode p, TreeNode q) { + while((root.val-p.val) * (root.val- q.val)>0){ + root=root.val>q.val ? root.left : root.right; + } + return root; + } + + + + } diff --git a/Week_02/id_1/LowestCommonAncestorBinaryTree236.java b/Week_02/id_1/LowestCommonAncestorBinaryTree236.java new file mode 100644 index 00000000..219e8b99 --- /dev/null +++ b/Week_02/id_1/LowestCommonAncestorBinaryTree236.java @@ -0,0 +1,35 @@ +package week02; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/14 14:49 + * @描述 LeetCode : 236. 二叉树的最近公共祖先 https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/ + */ +public class LowestCommonAncestorBinaryTree236 { + public static void main(String[] args) { + TreeNode node = new TreeNode(3); + node.left = new TreeNode(5); + node.right = new TreeNode(1); + 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 LowestCommonAncestorBinaryTree236().lowestCommonAncestor(node, node.right, node.left).toString()); + } + + /** + * Method 1 : 递归 ，从左右子树中分别查找 + * 时间复杂度 ： O(N) + * 空间复杂度 ： O(N) + */ + 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; + } +} diff --git a/Week_02/id_1/MinimumDistanceBetweenBstNodes783.java b/Week_02/id_1/MinimumDistanceBetweenBstNodes783.java new file mode 100644 index 00000000..ad19086d --- /dev/null +++ b/Week_02/id_1/MinimumDistanceBetweenBstNodes783.java @@ -0,0 +1,65 @@ +package week02; + +import java.util.LinkedList; +import java.util.List; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/13 14:32 + * @描述 LeetCode : 783. 二叉搜索树结点最小距离 https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/ + * 五毒神掌 ： 练习上一周的习题 + */ +public class MinimumDistanceBetweenBstNodes783 { + 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(2*N) ; 中序遍历 + 循环 + * 空间复杂度 ： O(N) ; list 集合 + */ + public int minDiffInBST(TreeNode root) { + List list = new LinkedList<>(); + inOrder(root, list); + int min = Integer.MAX_VALUE; + for (int i = 1; i < list.size(); i++) { + min = Math.min(min, list.get(i) - list.get(i - 1)); + } + return min; + } + + private void inOrder(TreeNode root, List list) { + if (root == null) return; + inOrder(root.left, list); + list.add(root.val); + inOrder(root.right, list); + } + + /** + * Method 2 : 递归的方法 ， 用全局变量记忆存储上一个节点 + * 时间复杂度 ： O(N) + * 空间复杂度 ： O(1) + */ + int min = Integer.MAX_VALUE; + TreeNode pre = null; + + public int minDiffInBST2(TreeNode root) { + dfs(root); + return min; + } + + private void dfs(TreeNode root) { + if (root == null) return; + dfs(root.left); + if (pre != null) min = Math.min(min, root.val - pre.val); + pre = root; + dfs(root.right); + } + +} diff --git a/Week_02/id_1/MinimunDepthBinaryTree111.java b/Week_02/id_1/MinimunDepthBinaryTree111.java new file mode 100644 index 00000000..9d1100ae --- /dev/null +++ b/Week_02/id_1/MinimunDepthBinaryTree111.java @@ -0,0 +1,67 @@ +package week02; + +import java.util.LinkedList; +import java.util.Queue; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/13 12:27 + * @描述 LeetCode : 111. 二叉树的最小深度 https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/ + * 五毒神掌 ： 隔一周练习一次 + */ +public class MinimunDepthBinaryTree111 { + public static void main(String[] args) { + TreeNode node = new TreeNode(5); + node.left = new TreeNode(1); + node.right = new TreeNode(4); + node.left.left = new TreeNode(3); + node.left.right = new TreeNode(6); + System.out.println(new MinimunDepthBinaryTree111().minDepth3(node)); + } + + /** + * Method 1 : DFS 递归解决 + * 时间复杂度 : O(N) ; + * 空间复杂度 ： O(N) ; + */ + public int minDepth(TreeNode root) { + if (root == null) return 0; + int left = minDepth(root.left); + int right = minDepth(root.right); + return (left == 0 || right == 0) ? right + left + 1 : Math.min(left, right) + 1; + } + + /** + * Method 2 : 方法一 DFS 精简版 + * 时间复杂度 ： O(N) ; + * 空间复杂度 ： O(1); 没有额外的空间开销 + */ + public int minDepth2(TreeNode root) { + if (root == null) return 0; + return (root.left == null || root.right == null) ? minDepth(root.right) + minDepth(root.left) + 1 : Math.min(minDepth(root.left), minDepth(root.right)) + 1; + } + + /** + * Method 3 : BFS 迭代 ； 使用队列 ; depth 记录深度；currentSize 记录当前层的数量； 只有数量为0时，当前层才算是深度加1； + * 时间复杂度 : O(N) ; + * * 空间复杂度 : O(N) ; + */ + public int minDepth3(TreeNode root) { + if (root == null) return 0; + Queue queue = new LinkedList<>(); + queue.offer(root); + int depth = 1,currentSize = 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; + if (--currentSize == 0) { + depth++; + currentSize = queue.size(); + } + } + return depth; + } + +} diff --git a/Week_02/id_1/NumberOfAtoms726.java b/Week_02/id_1/NumberOfAtoms726.java new file mode 100644 index 00000000..e5416035 --- /dev/null +++ b/Week_02/id_1/NumberOfAtoms726.java @@ -0,0 +1,69 @@ +package week02; + +import java.util.Map; +import java.util.Stack; +import java.util.TreeMap; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/12 16:04 + * @描述 LeetCode : 726. 原子的数量 https://leetcode-cn.com/problems/number-of-atoms/ + */ +public class NumberOfAtoms726 { + public static void main(String[] args) { + String str = "Mg(OH)2"; + String str2 = "K4(ON(SO3)2)2"; + new NumberOfAtoms726().countOfAtoms(str); + new NumberOfAtoms726().countOfAtoms(str2); + } + + /** + * 思考方式简单，实现比较麻烦 + * Method 1 : 使用 堆栈 + map 解决 + * 拆解为三种情况： + * 1、 ( 左括号，压栈 + * 2、 ) 右括号，出栈 + * 3、 字符串 + * 判断是否为 小写 + * 判断是否为 数字 + * 时间复杂度 : O(N) ; + * 空间复杂度 : O(N) ; + */ + public String countOfAtoms(String formula) { + int n = formula.length(); + Stack> stack = new Stack<>(); + stack.push(new TreeMap<>()); + + for (int i = 0; i < n; ) { + if (formula.charAt(i) == '(') { + stack.push(new TreeMap<>()); + i++; + } else if (formula.charAt(i) == ')') { + Map top = stack.pop(); + int start = ++i; + while (i < n && Character.isDigit(formula.charAt(i))) i++; + int multi = (i == start ? 1 : Integer.parseInt(formula.substring(start, i))); + for (String s : top.keySet()) { + Integer sum = top.get(s); + stack.peek().put(s, stack.peek().getOrDefault(s, 0) + sum * multi); + } + } else { + int start = i++; + while (i < n && Character.isLowerCase(formula.charAt(i))) i++; + String key = formula.substring(start, i); + start = i; + while (i < n && Character.isDigit(formula.charAt(i))) i++; + int multi = (i == start ? 1 : Integer.parseInt(formula.substring(start, i))); + // 当前 括号 内可能有重复的元素 + stack.peek().put(key, stack.peek().getOrDefault(key, 0) + multi); + } + } + StringBuilder sb = new StringBuilder(); + for (String s : stack.peek().keySet()) { + Integer num = stack.peek().get(s); + sb.append(s); + if (num > 1) sb.append(num); + } + return sb.toString(); + } +} diff --git a/Week_02/id_1/README.MD b/Week_02/id_1/README.MD new file mode 100644 index 00000000..0cc0f4fa --- /dev/null +++ b/Week_02/id_1/README.MD @@ -0,0 +1,39 @@ + +总题目数 : 17 +已完成 : 14 +未完成 ： 3 +第二周题目 +哈希表 +done 简单：https://leetcode-cn.com/problems/two-sum/ +done 简单：https://leetcode-cn.com/problems/valid-anagram/ +done 中等：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters +done 中等：https://leetcode-cn.com/problems/top-k-frequent-words +done 困难：https://leetcode-cn.com/problems/number-of-atoms/ ps: 尝试其他方式解题 + + +二叉树 +done 简单：https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/ +done 简单：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/ +done 中等：https://leetcode-cn.com/problems/symmetric-tree/ +done 中等：https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/ +done 中等：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/ +困难：https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/ + + +二叉搜索树 +done 简单：https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/ +done 简单：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/ +done 中等：https://leetcode-cn.com/problems/validate-binary-search-tree/ +done 中等：https://leetcode-cn.com/problems/range-sum-of-bst/ +中等：https://leetcode-cn.com/problems/contains-duplicate-iii/ +困难：https://leetcode-cn.com/problems/count-of-smaller-numbers-after-self/ + + +五毒神掌： +本周较难的题目： +1、不重复字符的最长字串 +2、前K个高频字符串 +3、原子的数量 + +本周加强练习的题目： + diff --git a/Week_02/id_1/RangeSumBst938.java b/Week_02/id_1/RangeSumBst938.java new file mode 100644 index 00000000..7559ada6 --- /dev/null +++ b/Week_02/id_1/RangeSumBst938.java @@ -0,0 +1,61 @@ +package week02; + +import java.util.ArrayList; +import java.util.List; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/14 17:54 + * @描述 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().rangeSumBST2(node, 7, 15)); + } + + /** + * Method 1 : 中序遍历 ， 然后在 有序集合中 计算和 ；当前 值 大于 R ,直接break,避免无效的循环； + * 时间复杂度 : O(N) ; 中序遍历 + 循环 + * 空间复杂度 : O(N) ; list 集合 + */ + public int rangeSumBST(TreeNode root, int L, int R) { + List list = new ArrayList<>(); + inOrder(root, list); + int sum = 0; + for (int i = 0; i < list.size(); i++) { + if (L <= list.get(i) && list.get(i) <= R) + sum += list.get(i); + if (list.get(i) > R) break; + } + return sum; + } + + private void inOrder(TreeNode root, List list) { + if (root == null) return; + inOrder(root.left, list); + list.add(root.val); + inOrder(root.right, list); + } + + /** + * Method 2 : DFS 使用 二叉搜索树的特性， 在递归中操作； + * L 的值大于当前根节点的值时，从根的右子树中找 + * R 的值小于当前根节点的值时，从根的左子树中找 + * 不然都要找 + * 时间复杂度 : O(N) ; + * 空间复杂度 : O(N) ; + */ + public int rangeSumBST2(TreeNode root, int L, int R) { + if(root==null) return 0; + if(root.valR) return rangeSumBST2(root.left,L,R); + return root.val+rangeSumBST2(root.right,L,R)+rangeSumBST2(root.left,L,R); + } + +} diff --git a/Week_02/id_1/SymmetricTree101.java b/Week_02/id_1/SymmetricTree101.java new file mode 100644 index 00000000..1981a324 --- /dev/null +++ b/Week_02/id_1/SymmetricTree101.java @@ -0,0 +1,84 @@ +package week02; + +import java.util.LinkedList; +import java.util.Queue; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/14 15:06 + * @描述 LeetCode : 101. 对称二叉树 https://leetcode-cn.com/problems/symmetric-tree/ + */ +public class SymmetricTree101 { + public static void main(String[] args) { + TreeNode node = new TreeNode(3); + 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(3); + System.out.println(new SymmetricTree101().isSymmetric(node)); + } + + /** + * Method 1 : BFS ，使用队列 + * 添加顺序： + * 1、左子树的左 + * 2、右子树的右 + * 3、左子树的右 + * 4、右子树的左 + * 时间复杂度 : O(N) ; + * 空间复杂度 : O(N) ; + */ + public boolean isSymmetric(TreeNode root) { + if (root == null || (root.left==null && root.right==null)) return true; + Queue queue = new LinkedList<>(); + queue.offer(root.left); + queue.offer(root.right); + while (!queue.isEmpty()) { + TreeNode node = queue.poll(); + TreeNode node2 = queue.poll(); + if (node == null && node2 == null) continue; + if (node == null || node2 == null) return false; + if (node.val != node2.val) return false; + queue.offer(node.left); + queue.offer(node2.right); + queue.offer(node.right); + queue.offer(node2.left); + } + return true; + } + + /** + * Method 2 : DFS + * 时间复杂度 ： O(N) + * 空间复杂度 ： O(N) + */ + public boolean isSymmetric2(TreeNode root) { + return isMirrer(root, root); + } + + private boolean isMirrer(TreeNode root, TreeNode root1) { + if (root == null && root1 == null) return true; + if (root == null || root1 == null) return false; + if (root.val != root1.val) return false; + return isMirrer(root.left, root1.right) && isMirrer(root.right, root1.left); + } + + /** + * Method 2 : DFS 优化版 + * 时间复杂度 ： O(N) + * 空间复杂度 ： O(N) + */ + public boolean isSymmetric3(TreeNode root) { + if (root == null) return true; + return isMirrer3(root.left, root.right); + } + + private boolean isMirrer3(TreeNode left, TreeNode right) { + if (left == null && right == null) return true; + if (left == null || right == null) return false; + return (left.val == right.val) && isMirrer3(left.left, right.right) && isMirrer3(left.right, right.left); + } + +} diff --git a/Week_02/id_1/TopKFrequentWords692.java b/Week_02/id_1/TopKFrequentWords692.java new file mode 100644 index 00000000..6811b1b1 --- /dev/null +++ b/Week_02/id_1/TopKFrequentWords692.java @@ -0,0 +1,68 @@ +package week02; + + +import java.util.*; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/12 9:30 + * @描述 LeetCode : 692. 前K个高频单词 https://leetcode-cn.com/problems/top-k-frequent-words/ + */ +public class TopKFrequentWords692 { + public static void main(String[] args) { + + + String[] strs = new String[]{"i", "love", "leetcode", "i", "love", "coding"}; + String[] strs2 = new String[]{"the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"}; + final List list = new TopKFrequentWords692().topKFrequent(strs, 2); + final List list2 = new TopKFrequentWords692().topKFrequent(strs2, 4); + for (String s : list) { + System.out.print(s + ","); + } + System.out.println(); + for (String s : list2) { + System.out.print(s + ","); + } + + } + + /** + * Method 1 : 使用优先队列， 需要重写 优先队列的比较方式 + * 时间复杂度 : O(N) ; + */ + public List topKFrequent(String[] words, int k) { + Map map = new HashMap<>(); + for (String word : words) map.put(word, map.getOrDefault(word, 0) + 1); + PriorityQueue pq = new PriorityQueue(new Comparator() { + @Override + public int compare(String o1, String o2) { + return map.get(o1) == map.get(o2) ? o1.compareTo(o2) : map.get(o2) - map.get(o1); + } + } + ); + List list = new LinkedList<>(); + for (String entry : map.keySet()) pq.offer(entry); + for (int i = 0; i < k; i++) list.add(pq.poll()); + return list; + } + + public List topKFrequent2(String[] words, int k) { + Map map = new HashMap<>(); + for (String word : words) { + map.put(word, map.getOrDefault(word, 0) + 1); + } + PriorityQueue> pq = new PriorityQueue<>( + (a, b) -> a.getValue() == b.getValue() ? a.getKey().compareTo(b.getKey()) : b.getValue() - a.getValue() + ); + for (Map.Entry entry : map.entrySet()) { + pq.offer(entry); + } + List list = new LinkedList<>(); + for (int i = 0; i < k; i++) { + list.add(pq.poll().getKey()); + } + return list; + } + + +} diff --git a/Week_02/id_1/TreeNode.java b/Week_02/id_1/TreeNode.java new file mode 100644 index 00000000..2a30c56d --- /dev/null +++ b/Week_02/id_1/TreeNode.java @@ -0,0 +1,22 @@ +package week02; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/10 10:09 + * @描述 + */ +public class TreeNode { + int val; + TreeNode left; + TreeNode right; + TreeNode(int val){this.val=val;} + + @Override + public String toString() { + return "TreeNode{" + + "val=" + val + + ", left=" + left + + ", right=" + right + + '}'; + } +} diff --git a/Week_02/id_1/TwoSum1.java b/Week_02/id_1/TwoSum1.java new file mode 100644 index 00000000..1ef2fb2b --- /dev/null +++ b/Week_02/id_1/TwoSum1.java @@ -0,0 +1,51 @@ +package week02; + +import java.util.HashMap; +import java.util.Map; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/11 11:50 + * @描述 LeetCode : 1. 两数之和 https://leetcode-cn.com/problems/two-sum/ + */ +public class TwoSum1 { + + public static void main(String[] args) { + final TwoSum1 twoSum1 = new TwoSum1(); + int[] i = twoSum1.twoSum(new int[]{2, 7, 11, 15}, 9); + for (int i1 : i) { + System.out.println(i1); + } + } + + /** + * Method 1 : 暴力法 ，两层循环 + * 时间复杂度 ： O(N*N) ; 空间复杂度 ： O(1) ； + */ + public int[] twoSum(int[] nums, int target) { + for (int i = 0; i < nums.length - 1; i++) { + for (int j = i + 1; j < nums.length; j++) { + if (target - nums[i] == nums[j]) { + return new int[]{i, j}; + } + } + } + throw new IllegalArgumentException("No result"); + } + + /** + * Method 2 : 利用 Map 记忆储存法 ，把循环中没有匹配的值存储进 map当中，后面循环时进行判断，map 匹配成功 即返回 + * 时间复杂度 ： O(N) + * 空间复杂度 ： O(N) + */ + public int[] twoSum2(int[] nums, int target) { + final Map map = new HashMap<>(); + for (int i = 0; i < nums.length; i++) { + final int temp = target - nums[i]; + if (map.containsKey(temp)) return new int[]{map.get(temp), i}; + map.put(nums[i], i); + } + throw new IllegalArgumentException("No result"); + } + +} diff --git a/Week_02/id_1/ValidAnagram242.java b/Week_02/id_1/ValidAnagram242.java new file mode 100644 index 00000000..747547eb --- /dev/null +++ b/Week_02/id_1/ValidAnagram242.java @@ -0,0 +1,53 @@ +package week02; + +import java.util.Arrays; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/11 12:37 + * @描述 LeetCode : 242. 有效的字母异位词 https://leetcode-cn.com/problems/valid-anagram/ + */ +public class ValidAnagram242 { + public static void main(String[] args) { + System.out.println(new ValidAnagram242().isAnagram("anagram", "nagaram")); + System.out.println(new ValidAnagram242().isAnagram("rat", "car")); + } + + /** + * Method 1 : 把两个字符串 转化成 char 数组，在排序比较两者是否一致 + * 字符串 转化成 数组 ，额外开销空间 两个数组 + * 数组内 排序 采用 快速排序，时间复杂度 NlogN + * 时间复杂度 : O(2NlogN) ; + * 空间复杂度 ： O(N) ； N 为 字符串的长度 + */ + public boolean isAnagram(String s, String t) { + if (s.length() != t.length()) return false; + final char[] charsOne = s.toCharArray(); + final char[] charsTwo = t.toCharArray(); + Arrays.sort(charsOne); + Arrays.sort(charsTwo); + return String.valueOf(charsOne).equals(String.valueOf(charsTwo)); + } + + /** + * Method 2 : 用一个 26 位 长度的数组来保存字符串内的字符数量。 无需排序 + * 第一个字符串中的字符 数组中的数量 ++ + * 第二个字符串中的字符 数组中的数量 -- + * 时间复杂度 ： O(N) ； + * 空间复杂度 ： O(2N) ; N 为 字符串的长度 + */ + public boolean isAnagram2(String s, String t) { + if (s.length() != t.length()) return false; + final int[] array = new int[26]; + final char[] charsOne = s.toCharArray(); + final char[] charsTwo = t.toCharArray(); + for (int i = 0; i < s.length(); i++) { + array[charsOne[i] - 'a']++; + array[charsTwo[i] - 'a']--; + } + for (int i : array) { + if (i != 0) return false; + } + return true; + } +} diff --git a/Week_02/id_1/ValidateBinarySearchTree98.java b/Week_02/id_1/ValidateBinarySearchTree98.java new file mode 100644 index 00000000..86e39da9 --- /dev/null +++ b/Week_02/id_1/ValidateBinarySearchTree98.java @@ -0,0 +1,84 @@ +package week02; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.Stack; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/12 17:45 + * @描述 LeetCode : 98. 验证二叉搜索树 https://leetcode-cn.com/problems/validate-binary-search-tree/ + */ +public class ValidateBinarySearchTree98 { + public static void main(String[] args) { +// TreeNode node = new TreeNode(5); +// node.left = new TreeNode(1); +// node.right = new TreeNode(4); +// node.right.left = new TreeNode(3); +// node.right.right = new TreeNode(6); + + 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(6); + node.right.left = new TreeNode(11); + node.right.right = new TreeNode(20); + +// TreeNode node = new TreeNode(0); +// node.left = new TreeNode(-1); + +// TreeNode node = new TreeNode(6); +// node.left = new TreeNode(2); +// node.right = new TreeNode(8); +// node.left.left = new TreeNode(0); +// node.left.right = new TreeNode(4); +// node.left.right.left = new TreeNode(3); +// node.left.right.right = new TreeNode(5); +// node.right.left = new TreeNode(7); +// node.right.right = new TreeNode(9); + System.out.println(new ValidateBinarySearchTree98().inorderTraversal(node)); + } + + + public List inorderTraversal(TreeNode root) { + List list = new ArrayList<>(); + if(root == null) return list; + Stack stack = new Stack<>(); + while(root != null || !stack.empty()){ + while(root != null){ + stack.push(root); + root = root.left; + } + root = stack.pop(); + list.add(root.val); + root = root.right; + + } + return list; + } + /** + * Method 1 : 中序遍历 为 升序 ; 不满足条件 即返回 false + * 时间复杂度 : O(N) + * 空间复杂度 : O(N) + **/ + public boolean isValidBST(TreeNode root) { + if(root==null) return true; + List list = new LinkedList(); + inOrder(root,list); + for(int i=1;i Date: Fri, 14 Jun 2019 18:52:45 +0800 Subject: [PATCH 09/26] Rename BinaryTreeLevelorderTraversal102.java to LeetCode_102_1.java --- ...{BinaryTreeLevelorderTraversal102.java => LeetCode_102_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{BinaryTreeLevelorderTraversal102.java => LeetCode_102_1.java} (100%) diff --git a/Week_02/id_1/BinaryTreeLevelorderTraversal102.java b/Week_02/id_1/LeetCode_102_1.java similarity index 100% rename from Week_02/id_1/BinaryTreeLevelorderTraversal102.java rename to Week_02/id_1/LeetCode_102_1.java From 6c73e35a62f6132cda522abe41e1abbf3bd72fb3 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:53:31 +0800 Subject: [PATCH 10/26] Rename ValidateBinarySearchTree98.java to LeetCode_98_1.java --- .../id_1/{ValidateBinarySearchTree98.java => LeetCode_98_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{ValidateBinarySearchTree98.java => LeetCode_98_1.java} (100%) diff --git a/Week_02/id_1/ValidateBinarySearchTree98.java b/Week_02/id_1/LeetCode_98_1.java similarity index 100% rename from Week_02/id_1/ValidateBinarySearchTree98.java rename to Week_02/id_1/LeetCode_98_1.java From e1f7fac9cfe5c8861a0ee549f2d964974e8200fe Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:53:49 +0800 Subject: [PATCH 11/26] Rename ValidAnagram242.java to LeetCode_242_1.java --- Week_02/id_1/{ValidAnagram242.java => LeetCode_242_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{ValidAnagram242.java => LeetCode_242_1.java} (100%) diff --git a/Week_02/id_1/ValidAnagram242.java b/Week_02/id_1/LeetCode_242_1.java similarity index 100% rename from Week_02/id_1/ValidAnagram242.java rename to Week_02/id_1/LeetCode_242_1.java From affeb24d04da93395037bb6ad49769cad734a303 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:54:04 +0800 Subject: [PATCH 12/26] Rename TwoSum1.java to LeetCode_1_1.java --- Week_02/id_1/{TwoSum1.java => LeetCode_1_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{TwoSum1.java => LeetCode_1_1.java} (100%) diff --git a/Week_02/id_1/TwoSum1.java b/Week_02/id_1/LeetCode_1_1.java similarity index 100% rename from Week_02/id_1/TwoSum1.java rename to Week_02/id_1/LeetCode_1_1.java From 3444ffdbec8c4ed6b0bcb9f8f5a3f454a7968090 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:54:19 +0800 Subject: [PATCH 13/26] Rename TopKFrequentWords692.java to LeetCode_692_1.java --- Week_02/id_1/{TopKFrequentWords692.java => LeetCode_692_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{TopKFrequentWords692.java => LeetCode_692_1.java} (100%) diff --git a/Week_02/id_1/TopKFrequentWords692.java b/Week_02/id_1/LeetCode_692_1.java similarity index 100% rename from Week_02/id_1/TopKFrequentWords692.java rename to Week_02/id_1/LeetCode_692_1.java From 87f20bf07dc0b44cf1d3dcb054f01fe6fcb9c0e4 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:54:35 +0800 Subject: [PATCH 14/26] Rename SymmetricTree101.java to LeetCode_101_1.java --- Week_02/id_1/{SymmetricTree101.java => LeetCode_101_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{SymmetricTree101.java => LeetCode_101_1.java} (100%) diff --git a/Week_02/id_1/SymmetricTree101.java b/Week_02/id_1/LeetCode_101_1.java similarity index 100% rename from Week_02/id_1/SymmetricTree101.java rename to Week_02/id_1/LeetCode_101_1.java From 4ffb8364da5d6105dbee7478dc10d0aecf6e1222 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:54:50 +0800 Subject: [PATCH 15/26] Rename RangeSumBst938.java to LeetCode_938_1.java --- Week_02/id_1/{RangeSumBst938.java => LeetCode_938_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{RangeSumBst938.java => LeetCode_938_1.java} (100%) diff --git a/Week_02/id_1/RangeSumBst938.java b/Week_02/id_1/LeetCode_938_1.java similarity index 100% rename from Week_02/id_1/RangeSumBst938.java rename to Week_02/id_1/LeetCode_938_1.java From 30b6350647d91df67c06e9f157d09eb6739a604f Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:55:03 +0800 Subject: [PATCH 16/26] Rename NumberOfAtoms726.java to LeetCode_726_1.java --- Week_02/id_1/{NumberOfAtoms726.java => LeetCode_726_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{NumberOfAtoms726.java => LeetCode_726_1.java} (100%) diff --git a/Week_02/id_1/NumberOfAtoms726.java b/Week_02/id_1/LeetCode_726_1.java similarity index 100% rename from Week_02/id_1/NumberOfAtoms726.java rename to Week_02/id_1/LeetCode_726_1.java From 35d33d70cfe189756c98ab85a4fc15bd8c54ae78 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:55:15 +0800 Subject: [PATCH 17/26] Rename MinimunDepthBinaryTree111.java to LeetCode_111_1.java --- .../id_1/{MinimunDepthBinaryTree111.java => LeetCode_111_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{MinimunDepthBinaryTree111.java => LeetCode_111_1.java} (100%) diff --git a/Week_02/id_1/MinimunDepthBinaryTree111.java b/Week_02/id_1/LeetCode_111_1.java similarity index 100% rename from Week_02/id_1/MinimunDepthBinaryTree111.java rename to Week_02/id_1/LeetCode_111_1.java From 8ee2797cafba360d514f20a38f92ff846253f2eb Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:55:29 +0800 Subject: [PATCH 18/26] Rename MinimumDistanceBetweenBstNodes783.java to LeetCode_783_1.java --- ...MinimumDistanceBetweenBstNodes783.java => LeetCode_783_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{MinimumDistanceBetweenBstNodes783.java => LeetCode_783_1.java} (100%) diff --git a/Week_02/id_1/MinimumDistanceBetweenBstNodes783.java b/Week_02/id_1/LeetCode_783_1.java similarity index 100% rename from Week_02/id_1/MinimumDistanceBetweenBstNodes783.java rename to Week_02/id_1/LeetCode_783_1.java From 03d21fed6a2c8d313ad44a4b44e673369209d1da Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:55:43 +0800 Subject: [PATCH 19/26] Rename LowestCommonAncestorBinaryTree236.java to LeetCode_236_1.java --- ...LowestCommonAncestorBinaryTree236.java => LeetCode_236_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{LowestCommonAncestorBinaryTree236.java => LeetCode_236_1.java} (100%) diff --git a/Week_02/id_1/LowestCommonAncestorBinaryTree236.java b/Week_02/id_1/LeetCode_236_1.java similarity index 100% rename from Week_02/id_1/LowestCommonAncestorBinaryTree236.java rename to Week_02/id_1/LeetCode_236_1.java From 205efda0f8e51baf7557b74eef731bb8da797108 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:55:57 +0800 Subject: [PATCH 20/26] Rename LowestCommonAncestorBinarySearchTree235.java to LeetCode_235_1.java --- ...CommonAncestorBinarySearchTree235.java => LeetCode_235_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{LowestCommonAncestorBinarySearchTree235.java => LeetCode_235_1.java} (100%) diff --git a/Week_02/id_1/LowestCommonAncestorBinarySearchTree235.java b/Week_02/id_1/LeetCode_235_1.java similarity index 100% rename from Week_02/id_1/LowestCommonAncestorBinarySearchTree235.java rename to Week_02/id_1/LeetCode_235_1.java From f734b06a2bf74514e2d09e587cc2126ccc7ef813 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:56:13 +0800 Subject: [PATCH 21/26] Rename LongestSubstringWithoutRepeatingCharacters3.java to LeetCode_3_1.java --- ...ubstringWithoutRepeatingCharacters3.java => LeetCode_3_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{LongestSubstringWithoutRepeatingCharacters3.java => LeetCode_3_1.java} (100%) diff --git a/Week_02/id_1/LongestSubstringWithoutRepeatingCharacters3.java b/Week_02/id_1/LeetCode_3_1.java similarity index 100% rename from Week_02/id_1/LongestSubstringWithoutRepeatingCharacters3.java rename to Week_02/id_1/LeetCode_3_1.java From 09a79b9bdbd6063696625f79e611ec2778e20d23 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:56:30 +0800 Subject: [PATCH 22/26] Rename BinaryTreeZigzagLevelOrderTraversal103.java to LeetCode_103_1.java --- ...yTreeZigzagLevelOrderTraversal103.java => LeetCode_103_1.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Week_02/id_1/{BinaryTreeZigzagLevelOrderTraversal103.java => LeetCode_103_1.java} (100%) diff --git a/Week_02/id_1/BinaryTreeZigzagLevelOrderTraversal103.java b/Week_02/id_1/LeetCode_103_1.java similarity index 100% rename from Week_02/id_1/BinaryTreeZigzagLevelOrderTraversal103.java rename to Week_02/id_1/LeetCode_103_1.java From 2b5ec4895b4ea6e47b2e9b13617ac852d1c38de0 Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Fri, 14 Jun 2019 18:57:25 +0800 Subject: [PATCH 23/26] Update README.MD --- Week_02/id_1/README.MD | 1 + 1 file changed, 1 insertion(+) diff --git a/Week_02/id_1/README.MD b/Week_02/id_1/README.MD index 0cc0f4fa..866bf40b 100644 --- a/Week_02/id_1/README.MD +++ b/Week_02/id_1/README.MD @@ -34,6 +34,7 @@ done 中等：https://leetcode-cn.com/problems/range-sum-of-bst/ 1、不重复字符的最长字串 2、前K个高频字符串 3、原子的数量 +下次练习 本周加强练习的题目： From 239e91d7932a3cdc00b61adfe21a29df8c74be2b Mon Sep 17 00:00:00 2001 From: AALuoXiang <1533047354@qq.com> Date: Sun, 16 Jun 2019 21:43:44 +0800 Subject: [PATCH 24/26] add weekly summary --- Week_02/id_1/README.MD | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/Week_02/id_1/README.MD b/Week_02/id_1/README.MD index 866bf40b..a4d26afd 100644 --- a/Week_02/id_1/README.MD +++ b/Week_02/id_1/README.MD @@ -38,3 +38,11 @@ done 中等：https://leetcode-cn.com/problems/range-sum-of-bst/ 本周加强练习的题目： +总结： +第二周了，感觉刷题更有感觉了，不知不觉当中，在 LeetCode上面的刷题的数量超过50了，下次老师再提问，自己就是50+的选手了 +这一周当中的题目主要是 哈希表 和 树 。 哈希表在日常使用率很高，Key 与 Value 的形式会让其功能很强大，比如说 去重、计数等等。 +这两周来说的话印象更深的是 树 ，两周的题目当中都有树的题目，还有相同的题目，可能是为了让咱们练习五毒神掌吧。 + 经过两周的刷题练习，能明显感觉到的一点是：看到题目后，第一想法里面需要使用哪种数据结构来解题了，这种感觉挺好。 + 第一周还在拣软柿子捏，第二周也是尽量的从难度为中等的开始，中午休息时间就练一练简单的题目，找一找爽一把的感觉，哈哈。 + 逐渐的感觉到 平时刷题 好像要形成习惯了，脑子里经常想着刷题的事，想着题目，模拟解题思路 + From cd21b9a8a6c511305ec6c265c162a09767cc3bac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=BD=97=E7=A5=A5?= Date: Mon, 17 Jun 2019 10:40:49 +0800 Subject: [PATCH 25/26] 703 --- Week_03/id_1/LeetCode_703_1.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Week_03/id_1/LeetCode_703_1.java diff --git a/Week_03/id_1/LeetCode_703_1.java b/Week_03/id_1/LeetCode_703_1.java new file mode 100644 index 00000000..b36ff38d --- /dev/null +++ b/Week_03/id_1/LeetCode_703_1.java @@ -0,0 +1,13 @@ +package id_1; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/17 10:34 + * @描述 LeetCode : 703. 数据流中的第K大元素 https://leetcode-cn.com/problems/kth-largest-element-in-a-stream/ + */ +public class LeetCode_703_1 { + public static void main(String[] args) { + System.out.println("111"); + } + +} From ae8cf1c8453741be42a00e4255d5c7975cbf9635 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=BD=97=E7=A5=A5?= Date: Sun, 23 Jun 2019 17:30:07 +0800 Subject: [PATCH 26/26] =?UTF-8?q?=E5=AE=8C=E6=88=90=E7=9A=84=E9=A2=98?= =?UTF-8?q?=E7=9B=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_03/id_1/LeetCode_102_1.java | 43 ++++++++++ Week_03/id_1/LeetCode_103_1.java | 40 +++++++++ Week_03/id_1/LeetCode_104_1.java | 21 +++++ Week_03/id_1/LeetCode_107_1.java | 37 ++++++++ Week_03/id_1/LeetCode_111_1.java | 24 ++++++ Week_03/id_1/LeetCode_200_1.java | 141 +++++++++++++++++++++++++++++++ Week_03/id_1/LeetCode_429_1.java | 133 +++++++++++++++++++++++++++++ Week_03/id_1/LeetCode_547_1.java | 39 +++++++++ Week_03/id_1/LeetCode_703_1.java | 88 ++++++++++++++++++- Week_03/id_1/README.md | 28 ++++++ Week_03/id_1/TreeNode.java | 22 +++++ 11 files changed, 615 insertions(+), 1 deletion(-) create mode 100644 Week_03/id_1/LeetCode_102_1.java create mode 100644 Week_03/id_1/LeetCode_103_1.java create mode 100644 Week_03/id_1/LeetCode_104_1.java create mode 100644 Week_03/id_1/LeetCode_107_1.java create mode 100644 Week_03/id_1/LeetCode_111_1.java create mode 100644 Week_03/id_1/LeetCode_200_1.java create mode 100644 Week_03/id_1/LeetCode_429_1.java create mode 100644 Week_03/id_1/LeetCode_547_1.java create mode 100644 Week_03/id_1/README.md create mode 100644 Week_03/id_1/TreeNode.java diff --git a/Week_03/id_1/LeetCode_102_1.java b/Week_03/id_1/LeetCode_102_1.java new file mode 100644 index 00000000..739ff3b0 --- /dev/null +++ b/Week_03/id_1/LeetCode_102_1.java @@ -0,0 +1,43 @@ +package id_1; + +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/19 12:59 + * @描述 LeetCode : 102. 二叉树的层次遍历 https://leetcode-cn.com/problems/binary-tree-level-order-traversal/ + */ +public class LeetCode_102_1 { + public static void main(String[] args) { + + } + + /** + * Method 1 : BFS 一套标准的 BFS 代码模板解决多类问题 + */ + public List> levelOrder(TreeNode root) { + List> list = new LinkedList<>(); + if(root==null) return list; + Queue queue = new LinkedList<>(); + queue.offer(root); + boolean flag=false; + while (!queue.isEmpty()){ + List linkedList = new LinkedList<>(); + int size = queue.size(); + for(int i=0;i> zigzagLevelOrder(TreeNode root) { + List> list = new LinkedList<>(); + if(root==null) return list; + Queue queue = new LinkedList<>(); + queue.offer(root); + boolean flag=false; + while (!queue.isEmpty()){ + List linkedList = new LinkedList<>(); + int size = queue.size(); + for(int i=0;i> levelOrderBottom(TreeNode root) { + List> list = new LinkedList<>(); + if(root==null) return list; + Queue queue = new LinkedList<>(); + queue.offer(root); + while (!queue.isEmpty()){ + List linkedList = new LinkedList<>(); + int size = queue.size(); + for(int i=0;i= grid.length || j >= grid[0].length || grid[i][j] == '0') return; + // dfs 当前的四个方向 + grid[i][j] = '0'; + dfs(grid, i + 1, j); + dfs(grid, i - 1, j); + dfs(grid, i, j + 1); + dfs(grid, i, j - 1); + } + + /** + * Method 2 : Union Find 合并集 + */ + public int numIslands2(char[][] grid) { + if (grid == null || grid.length == 0) return 0; + int[][] direction = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; + int row = grid.length; + int col = grid[0].length; + UnionFind unionFind = new UnionFind(grid); + for (int i = 0; i < row; i++) { + for (int j = 0; j < col; j++) { + if (grid[i][j] == '1') { + for (int[] d : direction) { + int x = i + d[0]; + int y = j + d[1]; + if (x >= 0 && x < row && y >= 0 && y < col && grid[x][y] == '1') { + int current = i * col + j; + int otherDirection = x * col + y; + unionFind.union(current, otherDirection); + } + } + } + } + } + return unionFind.count; + } + + + /** + * Union find 类实现 + */ + class UnionFind { + int count = 0; + int[] father; + int row, col; + + UnionFind(char[][] grid) { + row = grid.length; + col = grid[0].length; + father = new int[row * col]; + for (int i = 0; i < row; i++) { + for (int j = 0; j < col; j++) { + if (grid[i][j] == '1') { + int temp = i * col + j; + father[temp] = temp; + count++; + } + } + } + } + + /** + * 合并方法 + */ + public void union(int node1, int node2) { + int n1 = find(node1); + int n2 = find(node2); + if (n1 != n2) { + father[n1] = n2; + count--; + } + } + + /** + * 查找方法 + */ + public int find(int node) { + if (father[node] == node) return node; + return find(father[node]); + } + } +} diff --git a/Week_03/id_1/LeetCode_429_1.java b/Week_03/id_1/LeetCode_429_1.java new file mode 100644 index 00000000..bd158c97 --- /dev/null +++ b/Week_03/id_1/LeetCode_429_1.java @@ -0,0 +1,133 @@ +package id_1; + +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/19 12:25 + * @描述 LeetCode : 429. N叉树的层序遍历 https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/submissions/ + */ + +// Definition for a Node. +class Node { + public int val; + public List children; + + public Node() { + } + + public Node(int _val, List _children) { + val = _val; + children = _children; + } +}; + +public class LeetCode_429_1 { + + public static void main(String[] args) { + final Node node5 = new Node(5, null); + final Node node6 = new Node(6, null); + final LinkedList nodes = new LinkedList<>(); + nodes.add(node5); + nodes.add(node6); + final Node node3 = new Node(3, nodes); + final Node node2 = new Node(2, null); + final Node node4 = new Node(4, null); + final LinkedList nodes2 = new LinkedList<>(); + nodes2.add(node3); + nodes2.add(node2); + nodes2.add(node4); + final Node root = new Node(1, nodes2); + final List> lists = new LeetCode_429_1().levelOrder2(root); + for (List list : lists) { + for (Integer integer : list) { + System.out.print(integer + ","); + } + System.out.println(); + } + + } + + /** + * Method 1 : BFS 队列实现 + * 时间复杂度 ： O(N) + * 空间复杂度 ： O(N) + */ + public List> levelOrder(Node root) { + List> list = new LinkedList<>(); + if (root == null) return list; + + Queue queue = new LinkedList<>(); + List linkedList = new LinkedList<>(); + queue.offer(root); + int currentSize = 1; + while (!queue.isEmpty()) { + Node node = queue.poll(); + linkedList.add(node.val); + if (node.children != null) { + for (Node child : node.children) { + queue.offer(child); + } + } + if (--currentSize == 0) { + currentSize = queue.size(); + list.add(linkedList); + linkedList = new LinkedList<>(); + } + } + return list; + } + + /** + * Method 2 : BFS 不在外层创建 临时的 List , 在循环内部创建 + */ + public List> levelOrder2(Node root) { + List> list = new LinkedList<>(); + if (root == null) return list; + Queue queue = new LinkedList<>(); + queue.offer(root); + while (!queue.isEmpty()) { + List linkedList = new LinkedList<>(); + int size = queue.size(); + for (int i = 0; i < size; i++) { + Node node = queue.poll(); + linkedList.add(node.val); + if (node.children != null) { + for (Node child : node.children) { + queue.offer(child); + } + } + } + list.add(linkedList); + } + return list; + } + + public List> levelOrder3(Node root) { + List> ret = new LinkedList<>(); + + if (root == null) return ret; + + Queue queue = new LinkedList<>(); + + queue.offer(root); + + while (!queue.isEmpty()) { + List curLevel = new LinkedList<>(); + int len = queue.size(); + for (int i = 0; i < len; i++) { + Node curr = queue.poll(); + curLevel.add(curr.val); + for (Node c : curr.children) + queue.offer(c); + } + ret.add(curLevel); + } + + return ret; + } + +} + diff --git a/Week_03/id_1/LeetCode_547_1.java b/Week_03/id_1/LeetCode_547_1.java new file mode 100644 index 00000000..f323f677 --- /dev/null +++ b/Week_03/id_1/LeetCode_547_1.java @@ -0,0 +1,39 @@ +package id_1; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/20 12:44 + * @描述 LeetCode : 547. 朋友圈 https://leetcode-cn.com/problems/friend-circles/ + */ +public class LeetCode_547_1 { + + public static void main(String[] args) { + + } + + /** + * Method 1 : DFS 深度优先 + */ + public int findCircleNum(int[][] M) { + if (M == null || M.length == 0) return 0; + int count = 0; + for (int i = 0; i < M.length; i++) { + for (int j = 0; j < M.length; j++) { + if (M[i][j] == 1) { + count++; + dfs(M, i, j); + } + } + } + return count; + } + + private void dfs(int[][] m, int i, int j) { + if (i < 0 || j < 0 || i >= m.length || j >= m.length || m[i][j] == 0) return; + m[i][j] = 0; + dfs(m, i + 1, j); + dfs(m, i - 1, j); + dfs(m, i, j + 1); + dfs(m, i, j - 1); + } +} diff --git a/Week_03/id_1/LeetCode_703_1.java b/Week_03/id_1/LeetCode_703_1.java index b36ff38d..c9581395 100644 --- a/Week_03/id_1/LeetCode_703_1.java +++ b/Week_03/id_1/LeetCode_703_1.java @@ -1,5 +1,7 @@ package id_1; +import java.util.PriorityQueue; + /** * @创建人 luoxiang * @创建时间 2019/6/17 10:34 @@ -7,7 +9,91 @@ */ public class LeetCode_703_1 { public static void main(String[] args) { - System.out.println("111"); +// KthLargest largest = new KthLargest(3, new int[]{4, 5, 8, 2}); +// System.out.println(largest.add(3)); +// System.out.println(largest.add(5)); +// System.out.println(largest.add(10)); +// System.out.println(largest.add(9)); +// System.out.println(largest.add(4)); + int year=20; + int money=10000; + double rate=0.05; + System.out.println("-----------------------------------------------"); + comppounding(10,10000,0.05); + comppounding(20,10000,0.05); + comppounding(30,10000,0.05); + System.out.println("-----------------------------------------------"); + comppounding(10,10000,0.08); + comppounding(20,10000,0.08); + comppounding(30,10000,0.08); + System.out.println("-----------------------------------------------"); + comppounding(10,10000,0.1); + comppounding(20,10000,0.1); + comppounding(30,10000,0.1); + System.out.println("-----------------------------------------------"); + comppounding(10,20000,0.05); + comppounding(20,20000,0.05); + comppounding(30,20000,0.05); + System.out.println("-----------------------------------------------"); + comppounding(10,20000,0.08); + comppounding(20,20000,0.08); + comppounding(30,20000,0.08); + System.out.println("-----------------------------------------------"); + comppounding(10,20000,0.1); + comppounding(20,20000,0.1); + comppounding(30,20000,0.1); + System.out.println("-----------------------------------------------"); + comppounding(10,10000,0.045); + comppounding(20,10000,0.045); + comppounding(30,10000,0.045); + System.out.println("-----------------------------------------------"); + comppounding(10,20000,0.045); + comppounding(20,20000,0.045); + comppounding(30,20000,0.045); + comppounding(40,20000,0.045); + comppounding(50,20000,0.045); + } + + /** + * 复利计算 小程序 + */ + private static void comppounding(int year,int money,double rate){ + double sum=0; + for(int i=0;i queue; + int k=0; + public KthLargest(int k, int[] nums) { + queue=new PriorityQueue(k); + this.k=k; + for (int num : nums) { + add(num); + } + } + + public int add(int val) { + if(queue.size()