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); + } +} 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; + } + +} 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; + } +} 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; + } +} 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 + "->"); + } + } +} 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); + } + +} 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); + } + + +} diff --git a/Week_02/id_1/LeetCode_101_1.java b/Week_02/id_1/LeetCode_101_1.java new file mode 100644 index 00000000..1981a324 --- /dev/null +++ b/Week_02/id_1/LeetCode_101_1.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/LeetCode_102_1.java b/Week_02/id_1/LeetCode_102_1.java new file mode 100644 index 00000000..5a4d4da1 --- /dev/null +++ b/Week_02/id_1/LeetCode_102_1.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/LeetCode_103_1.java b/Week_02/id_1/LeetCode_103_1.java new file mode 100644 index 00000000..caa8a0e8 --- /dev/null +++ b/Week_02/id_1/LeetCode_103_1.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/LeetCode_111_1.java b/Week_02/id_1/LeetCode_111_1.java new file mode 100644 index 00000000..9d1100ae --- /dev/null +++ b/Week_02/id_1/LeetCode_111_1.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/LeetCode_1_1.java b/Week_02/id_1/LeetCode_1_1.java new file mode 100644 index 00000000..1ef2fb2b --- /dev/null +++ b/Week_02/id_1/LeetCode_1_1.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/LeetCode_235_1.java b/Week_02/id_1/LeetCode_235_1.java new file mode 100644 index 00000000..deeb7b8a --- /dev/null +++ b/Week_02/id_1/LeetCode_235_1.java @@ -0,0 +1,70 @@ +package week02; + +/** + * @创建人 luoxiang + * @创建时间 2019/6/11 12:56 + * @描述 LeetCode : 235. 二叉搜索树的最近公共祖先 https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/ + */ +public class LowestCommonAncestorBinarySearchTree235 { + public static void main(String[] args) { + 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 LowestCommonAncestorBinarySearchTree235().lowestCommonAncestor3(node, node.left, node.right).toString()); + } + + /** + * Method 1 : 利用二叉搜索树 的特性；父节点的右节点 大于 父节点。左节点 小于 父节点 ，以此类推。 + * 当两个传入的两个节点的 最小值 都要比父节点 大 的话，只需要从 右节点 中查找即可 + * 当两个传入的两个节点的 最大值 都要比父节点 小 的话，只需要从 左节点 中查找即可 + * 时间复杂度 ： O(logN) ; + * 空间复杂度 ： O(1) 没有额外的空间开销； + */ + public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + if (root == null || root == p || root == q) return root; + if (Math.min(p.val, q.val) > 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/LeetCode_236_1.java b/Week_02/id_1/LeetCode_236_1.java new file mode 100644 index 00000000..219e8b99 --- /dev/null +++ b/Week_02/id_1/LeetCode_236_1.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/LeetCode_242_1.java b/Week_02/id_1/LeetCode_242_1.java new file mode 100644 index 00000000..747547eb --- /dev/null +++ b/Week_02/id_1/LeetCode_242_1.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/LeetCode_3_1.java b/Week_02/id_1/LeetCode_3_1.java new file mode 100644 index 00000000..73e107ef --- /dev/null +++ b/Week_02/id_1/LeetCode_3_1.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 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/LeetCode_726_1.java b/Week_02/id_1/LeetCode_726_1.java new file mode 100644 index 00000000..e5416035 --- /dev/null +++ b/Week_02/id_1/LeetCode_726_1.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/LeetCode_783_1.java b/Week_02/id_1/LeetCode_783_1.java new file mode 100644 index 00000000..ad19086d --- /dev/null +++ b/Week_02/id_1/LeetCode_783_1.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/LeetCode_938_1.java b/Week_02/id_1/LeetCode_938_1.java new file mode 100644 index 00000000..7559ada6 --- /dev/null +++ b/Week_02/id_1/LeetCode_938_1.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/LeetCode_98_1.java b/Week_02/id_1/LeetCode_98_1.java new file mode 100644 index 00000000..86e39da9 --- /dev/null +++ b/Week_02/id_1/LeetCode_98_1.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> 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 new file mode 100644 index 00000000..c9581395 --- /dev/null +++ b/Week_03/id_1/LeetCode_703_1.java @@ -0,0 +1,99 @@ +package id_1; + +import java.util.PriorityQueue; + +/** + * @创建人 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) { +// 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()