白月光永恒_社区达人页

2022年10月

• 10.25 16:51:22
  发表了文章 2022-10-25 16:51:22

  Spirng

  在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！ 这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低~，可以更加专注的在业务的实现上！这是IOC的原型！

  
• 10.25 16:48:57
  发表了文章 2022-10-25 16:48:57

  JVM探究

  请谈谈你对JVM的理解？ java8虚拟机和之前的变化更新? - 什么是OOM，什么是栈溢出StackOverFlowError? 怎么分析? - JVM的常用调优参数有哪些? - 内存快照如何抓取，怎么分析Dump文件？ - 谈谈JVM中，类加载器你的认识

  

2022年09月

• 09.26 23:41:48
  发表了文章 2022-09-26 23:41:48

  leetcode第57题

  和上一道可以说是一个问题，只不过这个是给一个已经合并好的列表，然后给一个新的节点依据规则加入到合并好的列表。 解法一 对应 56 题的解法一，没看的话，可以先过去看一下。这个问题其实就是我们解法中的一个子问题没看的话，可以先过去看一下。这个问题其实就是我们解法中的一个子问题， 所以直接加过来就行了

  
• 09.26 23:39:12
  发表了文章 2022-09-26 23:39:12

  leetcode第56题

  常规的思想，将大问题化解成小问题去解决。 假设给了一个大小为 n 的列表，然后我们假设 n - 1 个元素的列表已经完成了全部合并，我们现在要解决的就是剩下的 1 个，怎么加到已经合并完的 n -1 个元素中。 这样的话分下边几种情况， 我们把每个范围叫做一个节点，节点包括左端点和右端点。 1. 如下图，新加入的节点左端点和右端点，分别在两个节点之间。这样，我们只要删除

  
• 09.26 23:36:49
  发表了文章 2022-09-26 23:36:49

  leetcode第55题

  当自己按照 45 题的思路写完的时候，看 Solution 的时候都懵逼了，这道题竟然这么复杂？不过 Solution 把问题抽象成动态规划的思想，以及优化的过程还是非常值得学习的。

  
• 09.26 23:34:37
  发表了文章 2022-09-26 23:34:37

  leetcode第54题

  在 leetcode 的 solution 和 discuss 看了下，基本就是这个思路了，只是实现上有些不同，怎么用来标记是否走过，当前方向，怎么遍历，实现有些不同，但本质上是一样的。就是充分理解题意，然后模仿遍历的过程。

  
• 09.26 23:33:36
  发表了文章 2022-09-26 23:33:36

  leetcode第53题

  解法一和解法二的动态规划，只是在定义的时候一个表示以 i 开头的子数组，一个表示以 i 结尾的子数组，却造成了时间复杂度的差异。问题就是解法一中求出了太多的没必要的和，不如解法二直接，只保存最大的和。

  
• 09.26 23:31:57
  发表了文章 2022-09-26 23:31:57

  leetcode第52题

  可以发现对于同一条副对角线，row + col 的值是相等的。 对于同一条主对角线，row - col 的值是相等的。 我们同样可以用一个 bool 型数组，来保存当前对角线是否有元素，把它们相加相减的值作为下标。 对于 row - col ，由于出现了负数，所以可以加 1 个 n，由 [ - 3, 3 ] 转换为 [ 1 , 7 ] 。

  
• 09.26 23:30:43
  发表了文章 2022-09-26 23:30:43

  leetcode第51题

  较经典的回溯问题了，我们需要做的就是先在第一行放一个皇后，然后进入回溯，放下一行皇后的位置，一直走下去，如果已经放的皇后的数目等于 n 了，就加到最后的结果中。然后再回到上一行，变化皇后的位置，然后去找其他的解。 期间如果遇到当前行所有的位置都不能放皇后了，就再回到上一行，然后变化皇后的位置。再返回到下一行。 说起来可能还费力些，直接看代码吧。

  
• 09.26 23:29:45
  发表了文章 2022-09-26 23:29:45

  leetcode第50题

  求幂次方，用最简单的想法，就是写一个 for 循环累乘。 至于求负幂次方，比如 2^{-10}2−10，可以先求出 2^{10}210，然后取倒数，1/2^{10}1/210 ，就可以了 double mul = 1; if (n > 0) { for (int i = 0; i < n; i++) { mul *= x; } } else { n = -n; for (int i = 0; i < n; i++) { mul *= x; } mul = 1 / mul; }

  
• 09.26 23:27:47
  发表了文章 2022-09-26 23:27:47

  leetcode第49题

  时间复杂度：两层 for 循环，再加上比较字符串，如果字符串最长为 K，总的时间复杂度就是 O（n²K）。 空间复杂度：O（NK），用来存储结果。 解法一算是比较通用的解法，不管字符串里边是大写字母，小写字母，数字，都可以用这个算法解决。这道题的话，题目告诉我们字符串中只有小写字母，针对这个限制，我们可以再用一些针对性强的算法。 下边的算法本质是，我们只要把一类的字符串用某一种方法唯一的映射到同一个位置就可以。

  
• 09.26 23:26:42
  发表了文章 2022-09-26 23:26:42

  leetcode第48题

  将一个矩阵顺时针旋转 90 度，并且不使用额外的空间。大概属于找规律的题，没有什么一般的思路，观察就可以了。 解法一 可以先转置，然后把每列对称交换交换一下

  
• 09.26 23:25:06
  发表了文章 2022-09-26 23:25:06

  leetcode第47题

  基本上都是在上道题的基础上改出来了，一些技巧也是经常遇到，比如先排序，然后判断和前一个是否重复。利用 Hash 去重的功能。利用原来的存储空间隐藏掉数据，然后再想办法还原。

  
• 09.26 23:23:39
  发表了文章 2022-09-26 23:23:39

  leetcode第46题

  这是自己开始想到的一个方法，考虑的思路是，先考虑小问题怎么解决，然后再利用小问题去解决大问题。没错，就是递归的思路。比如说， 如果只有 1 个数字 [ 1 ]，那么很简单，直接返回 [ [ 1 ] ] 就 OK 了。 如果加了 1 个数字 2， [ 1 2 ] 该怎么办呢？我们只需要在上边的情况里，在 1 的空隙，也就是左边右边插入 2 就够了。变成 [ [ 2 1 ], [ 1 2 ] ]。

  
• 09.26 23:22:36
  发表了文章 2022-09-26 23:22:36

  leetcode第45题

  时间复杂度：O（n）。 空间复杂度：O（1）。 这里要注意一个细节，就是 for 循环中，i < nums.length - 1，少了末尾。因为开始的时候边界是第 0 个位置，steps 已经加 1 了。如下图，如果最后一步刚好跳到了末尾，此时 steps 其实不用加 1 了。如果是 i < nums.length，i 遍历到最后的时候，会进入 if 语句中，steps 会多加 1 。

  
• 09.26 23:21:18
  发表了文章 2022-09-26 23:21:18

  leetcode第44题

  时间复杂度：text 长度是 T，pattern 长度是 P，那么就是 O（TP）。 空间复杂度：O（TP）。 同样的，和第10题一样，可以优化空间复杂度。

  
• 09.26 23:20:07
  发表了文章 2022-09-26 23:20:07

  leetcode第43题

  个位乘个位，得出一个数，然后个位乘十位，全部乘完以后，就再用十位乘以各个位。然后百位乘以各个位，最后将每次得出的数相加。十位的结果要补 1 个 0 ，百位的结果要补两个 0 。相加的话我们可以直接用之前的大数相加。直接看代码吧。

  
• 09.26 23:19:02
  发表了文章 2022-09-26 23:19:02

  leetcode第42题

  也就是红色区域中的水， 数组是 height = [ 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1 ] 。 原则是高度小于 2，temp ++，高度大于等于 2，ans = ans + temp，temp = 0。 temp 初始化为 0 ，ans 此时等于 2。 height [ 0 ] 等于 0 < 2，不更新。 height [ 1 ] 等于 1 < 2，不更新。 height [ 2 ] 等于 0 < 2， 不更新。 height [ 3 ] 等于 2 >= 2， 开始更新 height [ 4 ] 等于 1 < 2，temp = temp + 1 = 1。 h

  
• 09.26 23:16:25
  发表了文章 2022-09-26 23:16:25

  leetcode第41题

  对于这种要求空间复杂度的，我们可以先考虑如果有一个等大的空间，我们可以怎么做。然后再考虑如果直接用原数组怎么做，主要是要保证数组的信息不要丢失。目前遇到的，主要有两种方法就是交换和取相反数。

  
• 09.26 23:15:10
  发表了文章 2022-09-26 23:15:10

  leetcode第40题

  会发现出现了很多重复的结果，就是因为没有跳过重复的 1。在求 opt [ 1 ] 的时候就变成了 [ [ 1 ]，[ 1 ] ] 这样子，由于后边求的时候都是直接在原来每一个列表里加数字，所有后边都是加了两次了。

  
• 09.26 23:13:04
  发表了文章 2022-09-26 23:13:04

  leetcode第39题

  对回溯法又有了更深的了解，一般的架构就是一个大的 for 循环，然后先 add，接着利用递归进行向前遍历，然后再 remove ，继续循环。而解法二的动态规划就是一定要找到递进的规则，开始的时候就想偏了，导致迟迟想不出来。

  
• 09.26 23:11:03
  发表了文章 2022-09-26 23:11:03

  leetcode第38题

  难在了题目是什么意思呢？ 初始值第一行是 1。 第二行读第一行，1 个 1，去掉个字，所以第二行就是 11。 第三行读第二行，2 个 1，去掉个字，所以第三行就是 21。 第四行读第三行，1 个 2，1 个 1，去掉所有个字，所以第四行就是 1211。 第五行读第四行，1 个 1，1 个 2，2 个 1，去掉所有个字，所以第五航就是 111221。 第六行读第五行，3 个 1，2 个 2，1 个 1，去掉所以个字，所以第六行就是 312

  
• 09.26 00:06:06
  发表了文章 2022-09-26 00:06:06

  leetcode第37题

  从上到下，从左到右遍历每个空位置。在第一个位置，随便填一个可以填的数字，再在第二个位置填一个可以填的数字，一直执行下去直到最后一个位置。期间如果出现没有数字可以填的话，就回退到上一个位置，换一下数字，再向后进行下去。

  
• 09.26 00:04:59
  发表了文章 2022-09-26 00:04:59

  leetcode第36题

  一个 9 * 9 的数独的棋盘。判断已经写入数字的棋盘是不是合法。需要满足下边三点， • 每一行的数字不能重复 • 每一列的数字不能重复 • 9 个 3 * 3 的小棋盘中的数字也不能重复。 只能是 1 - 9 中的数字，不需要考虑数独最后能不能填满

  
• 09.26 00:02:53
  发表了文章 2022-09-26 00:02:53

  leetcode第34题

  第二种思路，参考这里。 我们开始更新 start 的时候，是 mid + 1，如果剩两个元素，例如 2 4，target = 6 的话，此时 mid = 0，start = mid + 1 = 1，我们返回 start + 1 = 2。如果 mid 是右端点，那么 mid = 1，start = mid + 1 = 2，这样就可以直接返回 start 了，不需要在返回的时候加 1 了。

  
• 09.26 00:00:57
  发表了文章 2022-09-26 00:00:57

  leetcode第34题

  从左向右遍历，一旦出现等于 target 的值就结束，保存当前下标。如果从左到右没有找到 target，那么就直接返回 [ -1 , -1 ] 就可以了，因为从左到右没找到，那么从右到左也一定不会找到的。如果找到了，然后再从右到左遍历，一旦出现等于 target 的值就结束，保存当前下标。 时间复杂度是 O（n）并不满足题意，但可以了解下这个思路，从左到右，从右到左之前也遇到过。

  
• 09.25 23:58:52
  发表了文章 2022-09-25 23:58:52

  leetcode第33题

  问题出在，当数组剩偶数长度的时候，mid = （start + end）/ 2，mid 取的是左端点。上图的例子， mid > end, 更新 start = mid，start 位置并不会变化。那么下一次 mid 的值也不会变，就死循环了。所以，我们要更新 start = mid + 1。 综上，找最小值的下标的代码就出来了，同时，由于我们找的是位置 0 对应的下标，所以偏移就是最小值的下标.

  
• 09.25 23:55:33
  发表了文章 2022-09-25 23:55:33

  leetcode第32题

  这几种算法，暴力破解和动态规划我觉得想的话，还是能分析出来的话，最后两种算法感觉是去挖掘题的本质得到的算法，普适性不是很强。但最后一种算法，从左到右，从右到左，是真的强。

  
• 09.25 23:53:40
  发表了文章 2022-09-25 23:53:40

  leetcode第31题

  我们想几个问题。 要想使得数字变大，只要任意一位变大就可以。 要想得到刚好大于原来的数字，要变个位。 这里变大数字，只能利用交换。 如果从个位开始，从右往左进行，找一个比个位大的，交换过来，个位的数字交换到了更高位，由于个位的数字较小，所以交换过去虽然个位变大了，但数字整体变小了。例如 1 3 2，把 2 和 3 交换，变成 1 2 3，个位变大了，但整体数字变小了。 个位不行，我们再看十位，如果从十位左边找一个更大的数字交换过来，和个位的情况是一样的，数字会变小。例如 4 1 2 3，把 2 和 4 交换，2 1 4 3，数字会变小。如果从

  
• 09.25 23:52:15
  发表了文章 2022-09-25 23:52:15

  leetcode第30题

  如上图，利用循环变量 i ，依次后移，判断每个子串是否符合即可。 怎么判断子串是否符合？这也是这个题的难点了，由于子串包含的单词顺序并不需要固定，如果是两个单词 A，B，我们只需要判断子串是否是 AB 或者 BA 即可。如果是三个单词 A，B，C 也还好，只需要判断子串是否是 ABC，或者 ACB，BAC，BCA，CAB，CBA 就可以了，但如果更多单词呢？那就崩溃了。 链接)的作者提出了，用两个 HashMap 来解决。首先，我们把所有的单词存到 HashMap 里，key 直接存单词，value 存单词出现的个数（因为给出的单词可能会有重复的，所以可能是 1 或 2 或者其他）。然后扫描子

  
• 09.25 23:49:39
  发表了文章 2022-09-25 23:49:39

  leetcode第29题

  这道题看起来简单，却藏了不少坑。首先，我们用一次一次减造成了超时，然后我们用递归实现了加倍加倍的减，接着由于 int 表示的数的范围不是对称的，最小的负数并不能转换为对应的相反数，所以我们将之前的算法思路完全逆过来，正数边负数，大于变小于，还是蛮有意思的。

  
• 09.25 23:46:02
  发表了文章 2022-09-25 23:46:02

  leetcode第28题

  返回一个字符串 needle 在另一个字符串 haystack 中开始的位置，如果不存在就返回 -1 ，如果 needle 长度是 0 ，就返回 0 。 就是一一比较就好，看下代码吧。

  
• 09.23 17:31:10
  发表了文章 2022-09-23 17:31:10

  leetcode第27题

  上边的解法，我们是如果不等于 val 就赋值。但如果按题目的想法，应该是如果等于 val 就移除。我们从正方面去想，也就是等于 val 的话，我们怎么体现移除呢？ 题目中有个说明我们没利用到，他告诉我们说 the order of those five elements can be arbitrary，就是说数组的顺序可以随便换，我们怎么充分利用呢？ 我们可以这样，如果当前元素等于 val 了，我们就把它扔掉，然后将最后一个值赋值到当前位置，并且长度减去 1。什么意思呢？ 比如 1 2 2 4 6，如果 val 等于 2 。那么当移动到 2 的时候，等于 val 了。我们就把最后一个位置的

  
• 09.23 17:29:56
  发表了文章 2022-09-23 17:29:56

  leetcode第26题

  for 循环遍历每个数，while 循环判断当前数和它的后一个数是否相等，相等就后移一个数，并且接着判断后移的数和它后边的数是否相等，然后一直循环下去。不相等就将后一个数保存起来，并且长度加 1，然后结束循环。

  
• 09.23 17:28:38
  发表了文章 2022-09-23 17:28:38

  leetcode第25题

  时间复杂度：while 循环中本质上我们只是将每个结点访问了一次，加上结点倒置访问的一次，所以总共加起来每个结点其实只访问了 2 次。所以时间复杂度是 O（n）。 空间复杂度：O（1）。 解法二递归 有没有被解法一的各种指针绕晕呢，我们有一个更好的选择，递归，这样看起来就会简洁很多。 public ListNode reverseKGroup(ListNode head, int k) { if (head == null) return null; ListNode point = head; //找到子链表的尾部 int i = k;

  
• 09.23 17:25:01
  发表了文章 2022-09-23 17:25:01

  leetcode第24题

  解法一 迭代 首先为了避免单独讨论头结点的情况，一般先申请一个空结点指向头结点，然后再用一个指针来遍历整个链表。 先来看一下图示：

  
• 09.23 17:22:53
  发表了文章 2022-09-23 17:22:53

  leetcode第23题

  时间复杂度：假设 N 是所有的数字个数，存到数组是 O（N），排序如果是用快速排序就是 O(Nlog_N)O(NlogN) ，存到链表是 O（N），所以取个最大的，就是 O(Nlog_N)O(NlogN)。 空间复杂度：新建了一个链表，O（N）。

  
• 09.23 17:20:54
  发表了文章 2022-09-23 17:20:54

  leetcode第22题

  而这个数列，其实除了括号匹配，还有很多类似的问题，其本质是一样的，例如， 2n 个人排队买票，其中 n 个人持 50 元，n 个人持 100 元。每张票 50 元，且一人只买一张票。初始时售票处没有零钱找零。请问这 2n 个人一共有多少种排队顺序，不至于使售票处找不开钱？ 对于一个无限大的栈，一共n个元素，请问有几种合法的入栈出栈形式？ P = a1 a2 a3 ... an，其中 ai 是矩阵。根据乘法结合律，不改变矩阵的相互顺序，只用括号表示成对的乘积，试问一共有几种括号化方案？ n 个结点可构造多少个不同的二叉树？

  
• 09.23 17:18:13
  发表了文章 2022-09-23 17:18:13

  leetcode第21题

  总 递归看起来，两个字，优雅！但是关于递归的时间复杂度，空间复杂度的求法，先留个坑吧。

  
• 09.23 17:17:00
  发表了文章 2022-09-23 17:17:00

  leetcode第20题

  括号匹配问题。 如果只有一种括号，我们完全可以用一个计数器 count ，遍历整个字符串，遇到左括号加 1 ，遇到右括号减 1，遍历结束后，如果 count 等于 0 ，则表示全部匹配。但如果有多种括号，像 ( [ ) ] 这种情况它依旧会得到 0，所以我们需要用其他的方法。 栈！ 遍历整个字符串，遇到左括号就入栈，然后遇到和栈顶对应的右括号就出栈，遍历结束后，如果栈为空，就表示全部匹配。

  
• 09.23 17:15:31
  发表了文章 2022-09-23 17:15:31

  leetcode第19题

  上边我们遍历链表进行了两次，我们如何只遍历一次呢。 看了 leetcode 的讲解。 想象一下，两个人进行 100m 赛跑，假设他们的速度相同。开始的时候，第一个人就在第二个人前边 10m ，这样当第一个人跑到终点的时候，第二个人相距第一个人依旧是 10m ，也就是离终点 10m。 对比于链表，我们设定两个指针，先让第一个指针遍历 n 步，然后再让它俩同时开始遍历，这样的话，当第一个指针到头的时候，第二个指针就离第一个指针有 n 的距离，所以第二个指针的位置就刚好是倒数第 n 个结点。

  
• 09.23 17:13:33
  发表了文章 2022-09-23 17:13:33

  leetcode第18题

  top18 和3Sum类似，只不过是找四个数，使得和为 target，并且不能有重复的序列。 如果之前没有做过3Sum可以先看看，自己在上边的基础上加了一个循环而已。

  
• 09.23 00:11:21
  发表了文章 2022-09-23 00:11:21

  leetcode第17题

  假如是 "23" ，那么 第 1 次 for 循环结束后变为 a, b, c； 第 2 次 for 循环的第 1 次 while 循环 a 出队，分别加上 d e f 然后入队，就变成 b c ad ae af 第 2 次 for 循环的第 2 次 while 循环 b 出队，分别加上 d e f 然后入队，就变成 c ad ae af bd be bf 第 2 次 for 循环的第 3 次 while 循环 c 出队，分别加上 d e f 然后入队，就变成 ad ae af bd be bf cd ce cf 这样的话队列的元素长度再也没有等于 1 的了就出了 while 循环。

  
• 09.23 00:09:09
  发表了文章 2022-09-23 00:09:09

  leetcode第16题

  受到上一题的启发，没有看的，推荐大家可以看一下。我们完全可以先将数组排序，然后先固定一个数字，然后利用头尾两个指针进行遍历，降低一个 O（n）的时间复杂度。 如果 sum 大于 target 就减小右指针，反之，就增加左指针。

  
• 09.23 00:07:34
  发表了文章 2022-09-23 00:07:34

  leetcode第15题

  参考了这里-Java-solution) 主要思想是，遍历数组，用 0 减去当前的数，作为 sum ，然后再找两个数使得和为 sum。 这样看来遍历需要 O（n），再找两个数需要 O（n²）的复杂度，还是需要 O（n³）。 巧妙之处在于怎么找另外两个数。 最最优美的地方就是，首先将给定的 num 排序。 这样我们就可以用两个指针，一个指向头，一个指向尾，去找这两个数字，这样的话，找另外两个数时间复杂度就会从 O（n²），降到 O（n）。 而怎么保证不加入重复的 list 呢？ 要记得我们的 nums 已经有序了，所以只需要找到一组之后，当前指针要移到和当前元素不同的地方。其次在遍

  
• 09.23 00:05:54
  发表了文章 2022-09-23 00:05:54

  leetcode第14题

  我们把原来的数组分成两部分，求出左半部分的最长公共前缀，求出右半部分的最长公共前缀，然后求出的两个结果再求最长公共前缀，就是最后的结果了。 求左半部分的最长公共前缀，我们可以继续把它分成两部分，按照上边的思路接着求。然后一直分成两部分，递归下去。 直到该部分只有 1 个字符串，那么最长公共子串就是它本身了，直接返回就可以了。

  
• 09.23 00:03:11
  发表了文章 2022-09-23 00:03:11

  leetcode第13题

  解法一 先来一种不优雅的，也就是我开始的想法。就是遍历字符串，然后转换就可以，但同时得考虑 IV，IX 那些特殊情况。

  
• 09.23 00:01:11
  发表了文章 2022-09-23 00:01:11

  leetcode第12题

  相当简洁了，主要就是把所有的组合列出来，因为罗马数字表示的大小就是把所有字母相加，所以每次 append 那个，再把对应的值减去就行了。 时间复杂度：不是很清楚，也许是 O（1）？因为似乎和问题规模没什么关系了。 空间复杂度：O（1）

  
• 09.22 23:58:55
  发表了文章 2022-09-22 23:58:55

  leetcode第11题

  我们理一下思路，大小是由长度和高度决定，如果选 0 到 8 就保证了长度最长，此时大小是 0 号柱子的高度 1 乘以长度 8 。我们如果想面积更大怎么做呢，只能减小长度，增加高度。是左边的柱子向右移动变成 1 号柱子呢？还是右边的柱子向左移动变成 7 号柱子呢？当然是哪边的柱子短就改哪边的！只有这样，高度才有可能增加。 例如我们如果把 8 号柱子变成 7 号柱子，此时长度减少了，然而高度还是 0 号柱子没有变化，所以面积就会减少。把 1 号柱子变成 2 号柱子就很好了，因为此时高度就变成了 8 号柱子的高度，面积就有可能会增加。 如果左右两边柱子相等该怎么办呢？随意！ 我们假设 1 号

  
• 09.22 23:56:35
  发表了文章 2022-09-22 23:56:35

  leetcode第10题

  上边的递归，为了方便理解，简化下思路。 为了判断 text [ 0，len ] 的情况，需要知道 text [ 1，len ] 为了判断 text [ 1，len ] 的情况，需要知道 text [ 2，len ] 为了判断 text [ 2，len ] 的情况，需要知道 text [ 3，len ] ... 为了判断 text [ len - 1，len ] 的情况，需要知道 text [ len，len ] text [ len，len ] 肯定好求 求出 text [ len，len ] 的情况，就知道了 text [ len - 1，len ] 求出 text [ le