- 博客(61)
- 收藏
- 关注
RSS订阅原创 396. 旋转函数
396. 旋转函数396. 旋转函数方法一：迭代396. 旋转函数方法一：迭代class Solution { public int maxRotateFunction(int[] nums) { int f = 0, n = nums.length, numSum = Arrays.stream(nums).sum(); for (int i = 0; i < n; i++) { f += i * nums[i];
2022-04-25 20:56:54
157
原创 技术提升扩展1
技术提升扩展11、问答1、什么情况会出现内存溢出，内存泄露？2、悲观锁和乐观锁是什么，如何实现，有哪些方式实现？3、线程与进程的区别？4、Java死锁以及如何避免？5、BIO、NIO、AIO 有什么区别？6、你所知道网络协议有那些？7、什么是双亲委派机制？8、工作中常用的 JVM 配置参数有哪些？2、编程1、问答1、什么情况会出现内存溢出，内存泄露？内存泄漏memory leak :是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄漏似乎不会有大的影响，但内存泄漏堆积后的后果就是内存溢出。J
2022-04-24 12:52:38
1224
原创 529. 扫雷游戏
529. 扫雷游戏529. 扫雷游戏方法一：深度优先搜索方法二：广度优先搜索529. 扫雷游戏方法一：深度优先搜索class Solution { //定义8个方向 int[] dx = {-1, 1, 0, 0, -1, 1, -1, 1}; int[] dy = {0, 0, -1, 1, -1, 1, 1, -1}; public char[][] updateBoard(char[][] board, int[] click) { int x
2021-10-19 17:58:36
1021
原创 126. 单词接龙 II
126. 单词接龙 II126. 单词接龙 II方法：广度优先遍历、深度优先遍历（回溯）126. 单词接龙 II方法：广度优先遍历、深度优先遍历（回溯）class Solution { public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) { List<List<String>> re
2021-10-12 16:31:08
122
原创 127. 单词接龙
127. 单词接龙127. 单词接龙方法一：广度优先遍历方法二：双向广度优先遍历127. 单词接龙方法一：广度优先遍历class Solution { public int ladderLength(String beginWord, String endWord, List<String> wordList) { //第 1 步：先将 wordList 放到哈希表里，便于判断某个单词是否在 wordList 里 Set<String>
2021-10-09 17:55:29
58
原创 Git处理开发时临时加塞的紧急任务
Git处理开发时临时加塞的紧急任务//1 将工作区已修改文件存入另一块单独区域，工作区变为HEADgit stash//2 本地修复紧急任务并commit提交//3 将原来的任务恢复git stash apply 或者 git stash pop 不保留此条数据（如果使用 apply后又使用了 pop, 需要使用 git reset --hard HEAD 恢复//4 查看当前存放区域git stash list//5 查看工作区状态git status//6 比较暂存区和工作区区别
2021-10-09 11:09:59
206
原创 515. 在每个树行中找最大值
515. 在每个树行中找最大值515. 在每个树行中找最大值核心还是二叉树的层序遍历515. 在每个树行中找最大值核心还是二叉树的层序遍历/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.v
2021-10-07 13:44:51
44
原创 433. 最小基因变化
最小基因变化最小基因变化双向宽搜记忆化版本最小基因变化双向宽搜记忆化版本class Solution { public int minMutation(String start, String end, String[] bank) { //定义五个集合，分别是合法基因集合，起始基因集合，目标基因集合， // 起始基因记忆集合，目标基因记忆集合 Set<String> dict = new HashSet<>(), st
2021-10-06 17:48:51
85
原创 51. N 皇后
51. N 皇后51. N 皇后方法一：普通回溯51. N 皇后方法一：普通回溯class Solution { private int n; private List<List<String>> res; private List<String> board; public List<List<String>> solveNQueens(int n) { this.n = n;
2021-10-06 15:00:42
62
原创 17. 电话号码的字母组合
17. 电话号码的字母组合17. 电话号码的字母组合方法一：回溯17. 电话号码的字母组合方法一：回溯class Solution { public List<String> letterCombinations(String digits) { if (digits == null || digits.length() == 0) { return new ArrayList<>(); } Map
2021-09-30 17:45:27
55
原创 169. 多数元素
169. 多数元素169. 多数元素方法一：哈希表方法二：排序方法三：随机化方法四：分治方法五：Boyer-Moore 投票算法169. 多数元素方法一：哈希表class Solution { private Map<Integer, Integer> countNums(int[] nums) { Map<Integer, Integer> counts = new HashMap<>(); for (int num : n
2021-09-30 15:11:54
49
原创 78. 子集
78. 子集78. 子集方法一：迭代法实现子集枚举方法二：递归法实现子集枚举78. 子集方法一：迭代法实现子集枚举class Solution { List<Integer> t = new ArrayList<>(); List<List<Integer>> ans = new ArrayList<>(); public List<List<Integer>> subsets(int[] n
2021-09-28 16:44:27
59
原创 50. Pow(x, n)
50. Pow（x, n）50. Pow(x, n)方法一：快速幂 + 递归方法二：快速幂 + 迭代50. Pow(x, n)方法一：快速幂 + 递归class Solution { public double myPow(double x, int n) { long N = n; return N >= 0 ? quickMul(x, N) : 1.0 / quickMul(x, -N); } public double quickM
2021-09-27 17:13:16
45
原创 47. 全排列 II
47. 全排列 II47. 全排列 II回溯搜索 + 剪枝47. 全排列 II回溯搜索 + 剪枝 public List<List<Integer>> permuteUnique(int[] nums) { int len = nums.length; List<List<Integer>> res = new ArrayList<>(); if (len == 0) {
2021-08-19 14:47:18
46
原创 46. 全排列
46. 全排列46. 全排列方法一：回溯46. 全排列方法一：回溯 public List<List<Integer>> permute(int[] nums) { int len = nums.length; //使用一个动态数组保存所有可能的全排列 List<List<Integer>> res = new ArrayList<>(); if (len == 0) {
2021-08-19 11:24:23
44
原创 77. 组合
77. 组合77. 组合方法一：根据搜索起点画出二叉树优化：分析搜索起点的上界进行剪枝方法二：按照每一个数选与不选画出二叉树77. 组合方法一：根据搜索起点画出二叉树 public List<List<Integer>> combine(int n, int k) { List<List<Integer>> res = new ArrayList<>(); if (k <= 0 || n <
2021-08-18 16:37:04
54
原创 105. 从前序与中序遍历序列构造二叉树
105. 从前序与中序遍历序列构造二叉树105. 从前序与中序遍历序列构造二叉树方法一：递归105. 从前序与中序遍历序列构造二叉树方法一：递归class Solution { public TreeNode buildTree(int[] preorder, int[] inorder) { int preLen = preorder.length; int inLen = inorder.length; if (preLen != inLen
2021-03-15 22:14:14
57
原创 236. 二叉树的最近公共祖先
236. 二叉树的最近公共祖先236. 二叉树的最近公共祖先方法一：后序遍历 DFS236. 二叉树的最近公共祖先方法一：后序遍历 DFSclass Solution { public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { if (root == null || root == p || root == q) { return root;
2021-03-15 21:27:34
58
原创 297. 二叉树的序列化与反序列化
297. 二叉树的序列化与反序列化297. 二叉树的序列化与反序列化方法一：深度优先搜索297. 二叉树的序列化与反序列化方法一：深度优先搜索/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public
2021-02-26 23:12:34
58
原创 111. 二叉树的最小深度
111. 二叉树的最小深度111. 二叉树的最小深度方法一：深度优先搜索方法二：广度优先搜索111. 二叉树的最小深度方法一：深度优先搜索class Solution { public int minDepth(TreeNode root) { if (root == null) { return 0; } if (root.left == null && root.right == null) {
2021-02-26 14:55:55
58
原创 104. 二叉树的最大深度
104. 二叉树的最大深度104. 二叉树的最大深度方法一：深度优先搜索方法二：广度优先搜索104. 二叉树的最大深度方法一：深度优先搜索class Solution { public int maxDepth(TreeNode root) { if (root == null) { return 0; } else { int leftHeight = maxDepth(root.left);
2021-02-26 12:59:10
41
原创 98. 验证二叉搜索树
98. 验证二叉搜索树98. 验证二叉搜索树方法一: 递归方法二：中序遍历方法三：中序遍历（递归）98. 验证二叉搜索树方法一: 递归class Solution { public boolean isValidBST(TreeNode root) { return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE); } public boolean isValidBST(TreeNode node, long
2021-02-25 21:05:34
38
原创 226. 翻转二叉树
226. 翻转二叉树226. 翻转二叉树方法一：递归（自底向上）方法二：递归（自顶向下）方法三：迭代226. 翻转二叉树方法一：递归（自底向上）class Solution { public TreeNode invertTree(TreeNode root) { if (root == null) { return null; } TreeNode left = invertTree(root.left);
2021-02-25 19:50:15
39
原创 22. 括号生成
22. 括号生成22. 括号生成方法一：深度优先遍历方法二：广度优先遍历22. 括号生成方法一：深度优先遍历class Solution { public List<String> generateParenthesis(int n) { List<String> list = new ArrayList<String>(); generate(list, 0, 0, n, ""); return list;
2021-02-25 14:43:43
36
原创 200. 岛屿数量
200. 岛屿数量200. 岛屿数量思路一：深度优先遍历DFS思路二：广度优先遍历 BFS方法三：并查集200. 岛屿数量思路一：深度优先遍历DFSclass Solution { public int numIslands(char[][] grid) { int count = 0; for (int i = 0; i < grid.length; i++) { for (int j = 0; j < grid[0].le
2021-02-16 15:34:39
47
原创 347. 前 K 个高频元素
347. 前 K 个高频元素347. 前 K 个高频元素解法一：粗暴排序法解法二：最小堆解法三：桶排序法347. 前 K 个高频元素解法一：粗暴排序法最简单粗暴的思路就是 使用排序算法对元素按照频率由高到低进行排序，然后再取前 k 个元素。可以发现，使用常规的诸如 冒泡、选择、甚至快速排序都是不满足题目要求，它们的时间复杂度都是大于或者等于 O(nlogn)，而题目要求算法的时间复杂度必须优于 O(nlogn)。复杂度分析时间复杂度：O(nlogn)，n 表示数组长度。首先，遍历一遍数组统计元
2021-02-15 22:43:49
61
原创 剑指 Offer 49. 丑数
剑指 Offer 49. 丑数剑指 Offer 49. 丑数方法一：堆方法二： 动态规划剑指 Offer 49. 丑数方法一：堆class Ugly { public int[] nums = new int[1690]; Ugly() { HashSet<Long> seen = new HashSet(); //默认小顶堆 PriorityQueue<Long> heap = new PriorityQueue
2021-02-15 14:06:41
37
原创 264. 丑数 II
264. 丑数 II264. 丑数 II方法一：堆方法二： 动态规划264. 丑数 II方法一：堆class Ugly { public int[] nums = new int[1690]; Ugly() { HashSet<Long> seen = new HashSet(); //默认小顶堆 PriorityQueue<Long> heap = new PriorityQueue<Long>();
2021-02-15 14:06:23
27
原创 剑指 Offer 40. 最小的k个数
剑指 Offer 40. 最小的k个数剑指 Offer 40. 最小的k个数方法一：排序方法二：构造大顶堆方法三：构造小顶堆方法四：快排思想剑指 Offer 40. 最小的k个数方法一：排序class Solution { public int[] getLeastNumbers(int[] arr, int k) { int[] vec = new int[k]; Arrays.sort(arr); for (int i = 0; i <
2021-02-14 15:01:12
74
原创 429. N 叉树的层序遍历
429. N 叉树的层序遍历429. N 叉树的层序遍历方法一：利用队列实现广度优先搜索方法二：简化的广度优先搜索方法三：递归429. N 叉树的层序遍历方法一：利用队列实现广度优先搜索class Solution { public List<List<Integer>> levelOrder(Node root) { List<List<Integer>> result = new ArrayList<>();
2021-02-08 22:58:16
59
原创 589. N叉树的前序遍历
589. N叉树的前序遍历589. N叉树的前序遍历方法一：递归方法二：迭代589. N叉树的前序遍历方法一：递归class Solution { public List<Integer> preorder(Node root) { ArrayList<Integer> res = new ArrayList<Integer>(); preorder(root, res); return res; }
2021-02-08 21:52:55
39
原创 590. N叉树的后序遍历
590. N叉树的后序遍历590. N叉树的后序遍历方法一：递归方法二：迭代590. N叉树的后序遍历方法一：递归class Solution { public List<Integer> postorder(Node root) { List<Integer> res = new ArrayList<Integer>(); postorder(root, res); return res; }
2021-02-08 18:41:22
109
原创 102. 二叉树的层序遍历
102. 二叉树的层序遍历102. 二叉树的层序遍历方法一：广度优先搜索102. 二叉树的层序遍历方法一：广度优先搜索class Solution { public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> ret = new ArrayList<List<Integer>>(); if (root
2021-02-08 18:01:38
39
原创 145. 二叉树的后序遍历
145. 二叉树的后序遍历145. 二叉树的后序遍历方法一：递归方法二：迭代145. 二叉树的后序遍历方法一：递归class Solution { public List<Integer> postorderTraversal(TreeNode root) { List<Integer> res = new ArrayList<Integer>(); postorder(root, res); return r
2021-02-08 17:20:38
43
原创 144. 二叉树的前序遍历
144. 二叉树的前序遍历144. 二叉树的前序遍历方法一：递归方法二：迭代144. 二叉树的前序遍历方法一：递归class Solution { public List<Integer> preorderTraversal(TreeNode root) { List<Integer> res = new ArrayList<Integer>(); preorder(root, res); return res
2021-02-06 14:13:46
66
原创 94. 二叉树的中序遍历
94. 二叉树的中序遍历94. 二叉树的中序遍历方法一：递归方法二：迭代94. 二叉树的中序遍历方法一：递归class Solution { public List<Integer> inorderTraversal(TreeNode root) { List<Integer> res = new ArrayList<Integer>(); inorder(root, res); return res;
2021-02-06 13:49:39
37
原创 49. 字母异位词分组
49. 字母异位词分组49. 字母异位词分组方法一：排序方法二：计数49. 字母异位词分组方法一：排序class Solution { public List<List<String>> groupAnagrams(String[] strs) { if(strs.length == 0){ return new ArrayList(); } Map<String, List<Strin
2021-01-22 21:58:59
37
原创 242. 有效的字母异位词
49. 字母异位词分组49. 字母异位词分组方法一：排序方法二：哈希表原理方法三：哈希表49. 字母异位词分组方法一：排序class Solution { public boolean isAnagram(String s, String t) { if (s.length() != t.length()) { return false; } char[] str1 = s.toCharArray(); c
2021-01-22 15:06:08
33
原创 66. 加一
66. 加一66. 加一Java 数学解题66. 加一Java 数学解题class Solution { public int[] plusOne(int[] digits) { for (int i = digits.length - 1; i >= 0; i--) { digits[i]++; digits[i] = digits[i] % 10; if (digits[i] != 0) {
2021-01-22 14:12:47
41
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人