zsysingapore的博客

一个 Java 程序的运行是 main 线程和多个其他线程同时运行。

下一层宽度 = list.getLast() - list.getFirst() + 1。list：存与 q 中节点一一对应的“位置编号 index”list 存这些节点在完全二叉树中的位置编号 index。(1)用 BFS 按层遍历二叉树。q 和 list 中剩下的就是下一层的节点及其编号。list 这个链表的头部取出并删除第一个元素。右孩子 = 2 * index + 1。(4)res 记录所有层中最大的宽度。左孩子 = 2 * index。根节点 index = 1。q 存当前层的真实节点；

我们定义两个指针 i 和 j 分别指向 num 1 和 num 2 的末尾，即最低位，同时定义一个变量 add 维护当前是否有进位，然后从末尾到开头逐位相加即可。你可能会想两个数字位数不同怎么处理，这里我们统一在指针当前下标处于负数的时候返回 0，等价于对位数较短的数字进行了补零操作，这样就可以除去两个数字位数不同情况的处理，

（2）每一个字符串中，在进行二次遍历，把每一个字符串变成字符数组，去遍历每个字符串的字符，如果正好等于x，记录到结果列表中（标记是在哪个字符串中，只需记录1次，所以要用到break）（1）字符串数组中，取出每一个的字符串。

遍历到一个新节点 cur 时，如果 cur.val 比栈顶的小或相等，那它也“没有更大值”，先压栈。对栈顶那个节点来说，当前的 cur.val 就是它“后面第一个更大的值”，res 是“答案列表”，按链表顺序存每个节点的【下一个更大节点的值】。那就把栈顶弹出，同时在结果数组对应位置写上 cur.val。你之前已经 res.add(0) 预填了 0，直接保留就行。(2)从栈底到栈顶，节点值是单调递减的。栈里剩下的节点就说明后面再也没更大的了，它在结果数组中的位置 = 0。这个节点的值 = 2。

因为是子数组，使用确定完左边界的值，要挨个加元素到右边界num[i]左区间a的话等于取max(0，i-nusm[i])首先子数组的取值范围是[a,b]右区间b的话等于当前的索引i，

大写字符与其对应的小写字符的 ASCII 的差为 32，32 这个值如果敏感的话，它是 2。char[] ch：当前正在操作的状态/路径载体（我们在 ch 上改大小写）而这两者合并起来，就是给这个字符做一次不进位的加法，即异或上 1 << 5。int index：当前决策到第几个字符（也就是“递归到了第几层”）如果字符是小写字符，减去 32 得到大写字符；如果字符是大写字符，加上 32 得到小写字符。，在编程语言中，可以表示为 1 << 5。index 就是“当前处理到哪一位了”，深度优先遍历（回溯）

对于「两个点」或者「目录名」，我们则可以用一个栈来维护路径中的每一个目录名。当我们遇到「两个点」时，需要将目录切换到上一级，因此只要栈不为空，我们就弹出栈顶的目录。这样一来，我们只需要遍历 names 中的每个字符串并进行上述操作即可。在所有的操作完成后，我们将从栈底到栈顶的字符串用 / 进行连接，再在最前面加上 / 表示根目录，就可以得到简化后的规范路径。对于「空字符串」以及「一个点」，我们实际上无需对它们进行处理，因为「空字符串」没有任何含义，而「一个点」表示当前目录本身，我们无需切换目录。

所以直接i=1，用nums[i]和nums[i-1]进行比较，然后设置一个变量保存当前索引，并返回。前后元素是不同的，我们返回峰值的索引是任意的，选择任意一个峰值返回。（1）传统思路，因为nums[i]!=nums[i+1]（2）时间复杂度O（logN）二分查找。

用hashmap记录元素和元素出现的频率，然后通过ma.get()方法，获取频率等于1的元素然后返回。

判断反转后的数字res*10+tep是否在该区间里面。

如果删除 s[right]，则剩余字符的下标范围是 [left,right−1]。分别检查这两个下标范围中的子串是不是回文串，如果其中至少有一个子串是回文串，则可以通过删除一个字符将 s 变成回文串，否则不可以通过删除一个字符将 s 变成回文串。如果移动过程中，两个指针指向的字符总是相同，则字符串是回文串。特别地，如果移动过程中 s[left]=s[right] 总是成立，则 s 是回文串，不需要删除任何字符。=s[right]，则需要删除 s[left] 或 s[right]，才可能将 s 变成回文串。

【代码】2025年--Lc231-350. 两个数组的交集 II-Java版。

【代码】2025年--Lc230-119. 杨辉三角 II-Java版。

1 表示“最左侧边界的前一位”。当一开始就出现一段合法串（比如 “()” 从下标 0 开始），长度就能算成 i - (-1)。用栈存“尚未匹配的左括号索引”；额外压入一个哨兵 -1 当“基准起点”。遇到右括号)时先弹出一个左括号（；若左括号栈空了，说明这个)无法匹配，就把它的索引当成新的基准压栈；若栈没空，当前有效长度 = 当前索引 i − 栈顶索引，更新答案。如果某个)不匹配，我们把它的下标压栈，充当“新的左边界前一位”。leetcode模式。

【代码】2025年--Lc228-523. 连续的子数组和（带测试用例）-Java版。

岛屿是1，每座岛屿只能由水平方向和竖直方向上相邻（该元素的上下左右的方向）的陆地陆续连接形成。

二叉树的每个节点的左右子树的高度差的绝对值不超过 1，则二叉树是平衡二叉树。根据定义，一棵二叉树是平衡二叉树，当且仅当其所有子树也都是平衡二叉树，因此可以使用递归的方式判断二叉树是不是平衡二叉树，递归的顺序可以是自顶向下（也可自底向下）。平衡二叉树的要求是：对于树上任意一个节点，它的左子树高度和右子树高度的差值不超过 1。并且左右子树本身也都是平衡的。这个题不是在判断是不是二叉搜索树（BST），而是在判断“这棵树是不是平衡二叉树（AVL风格）”。(1)判断左右子树的高度差是不是小于1。

（4）调用方法递归遍历（p树的左孩子节点，q树的左孩子节点）&&（p树的右孩子节点，q树的右孩子节点。（3）考虑两棵树一棵是null，一棵树非null的情况。（2）考虑两棵树其中1棵树是null的情况。（1）考虑两棵树都是null的情况。（5）其他情况直接返回false；方法2:不带测试用例。

如果根节点不空，递归遍历左子树和右子树，用Math.max(左子树的深度、右子树的深度）+1计算整个树的最大深度。

Java 里应该用 Collections.reverse(res);这个工具方法原地反转整个 List<List>（2）定义一个大列表，也就是列表的列表，存储所有层的结果。如果队首元素左右孩子，分别把左右孩子加入到队列中。（5）最后把当前层的列表添加到大列表中。先取出队首元素并删除poll()2）定义1个小列表存储每层的值。1）计算此时队列中元素的个数。队首元素的值加入小列表中。（4）如果队列不为空。3）遍历当前层的元素。

根左右，如果根节点的左节点不为空，递归遍历当前res的左节点。如果根节点的右节点不为空，递归遍历当前res的右节点。

根节点入队，再去遍历根节点的孩子节点（左右）

输入是按层序遍历进行序列化表示，每组子节点由null隔开。都是先把自己的子节点遍历完，再去遍历根节点。

(3)将output中的节点依次弹出并存入结果列表result中，这样得到的顺序就是后序遍历（左-右-根）。st的根入栈了先弹出。然后st的根节点的左子节点先入栈，右子节点后入栈。这样st出栈顺序是右-左。添加一个辅助栈，节点入栈的顺序是根右左，这样节点弹出的时候才是左右根。(1)根节点首先被压入stack中，然后被弹出并压入output中。out 里存的是“根-右 左”这种倒着的遍历顺序。我从 out 反向弹出时，就变成了“左 右 根”stack用于存储需要遍历的节点。用栈实现，正常的后序遍历是左右根。

递归的时候不小心把根节点也递归了，导致stackoverflow（栈溢出），应该是添加当前的根节点的值。（3）另外写1个函数，执行递归逻辑，里面包含从左右根的遍历顺序，并把该结果列表加入根节点的值。（1）定义树节点，包括int val,左节点，右节点。（4）创建树节点进行验证输出。（2）传入根节点进行递归。后序遍历包括根左右。

2个链表的合并，需要2个指针，分别指向2个链表的头结点，并把对应的指针后移，直到2个链表遍历完成。3个链表的合并，需要3个指针，分别指向3个链表的头结点，并把对应的指针后移，直到3个链表遍历完成。lists[0] → 1 → 4 → 5 → null （头节点是 1）lists[1] → 1 → 3 → 4 → null （头节点是 1）lists[2] → 2 → 6 → null （头节点是 2）k个节点的优化就是采用小根堆。用小根堆存储k个节点，每次弹出堆顶元素，

思路，我们要明确list1和list2本身就是有序的，所以我们要比较list1的值和list2的值，然后再放入新的链表中。如果比较完，list1或list2元素还有剩余，我们直接接入到新链表后面。

【代码】2025年--Lc213-2000. 反转单词前缀-Java版。

（1）快速排序：快速排序（Quick Sort）是一种高效的排序算法，基于分治法（Divide and Conquer）的思想。它的核心是通过选择一个基准元素（pivot），将列表分为两部分：一部分小于基准元素，另一部分大于基准元素，然后递归地对这两部分进行排序。2）分区：将列表重新排列，**使得所有小于基准元素的元素都在基准的左侧，所有大于基准元素的元素都在基准的右侧。1）选择基准元素：从列表中选择一个元素作为基准（pivot）。3）递归排序：对基准元素左侧和右侧的子列表分别递归地进行快速排序。

(4)当遍历完 num1，num2 后跳出循环，并根据 carry 值决定是否在头部添加进位 1，最终返回 res 即可。双指针i，j分别指向nums1、nums2的末尾。(2)进位：carry=tmp/10。(1)当前位:i+j+carry。

【代码】2025年--Lc207- 1143. 最长公共子序列(动态规划）--Java版。

指针移动单调递增，最多移动 m+n 次，因此时间复杂度为 O(m+n)时间复杂度：O(m+n)。

统计每个字符的出现次数，尽量把偶数次全部用上，奇数次则用其最大的偶数部分（比如 5 次只能用 4 次），最后如果存在至少一个奇数次，可以把其中一个字符放在回文中心，再多加 1。因为有奇数频次（a 或 b），中心可放 1 个 → 最终 6 + 1 = 7。累加偶数部分：a(0) + b(0) + c(4) + d(2) = 6。能构成的最长回文长度是 7（例如 “dccaccd”）。频次：a:1, b:1, c:4, d:2。

temp 是一个中间变量，表示：“把当前值 i 接在它的前驱值 i - difference 后面后，得到的以 i 结尾的最长等差子序列长度”。值（value）：遍历到当前位置为止，以数值 v 结尾、公差为 difference 的最长等差子序列长度。// 更新“以 i 结尾”的最长长度。键（key）：数组中的“数值” v。

（比如第一次找的5，6 ，说明元素6的dp[2]=2,cnt[2]=1；第二次找的4，6）,说明元素6的dp[2]=2,cnt[2]=2.如果（dp[i]=dp[j]+1),说明长度保持不变，但是计数器要加上之前序列的技术。cnt[i]=cnt[i]+cnt[j].dp[i]=dp[i]+1 此时计数的数组等于cnt[i]=cnt[j];如果（dp[i]<dp[j]+1),说明遇到了更大的长度，dp[i]要更新长度。我们要从头到尾遍历dp[i]数组,如果每个dp[i]==max=1最大值。

不同数字只有 {1,2} 两个，循环结束 set.size() 也只有 2，没法在循环内返回“第三大”。你写的是 compare(b, a)（把参数反过来），等价于“降序比较”，因此会让大的数排在前面，得到的是大根堆。当 set.size()==3 时才会 return x，如果全程都达不到 3 个不同值，就不会提前返回。不同数字 {5,4} 也只有 2 个，同理循环里不会触发 set.size()==3，最后返回最大值 5。Integer.compare(x, y)：x<y 返回负数；

因为t串是由s串随机乱排再加一个小写字母组成。（s，t串都是小写字母）遍历字符数组for(char a:s.toCharArray())(2)两个计数器相减，就是添加那个字符的ascii码数值。(1)两个计数器，分别计算两个字符串的ASCII码和。(3)将ascii码数值转换成字符（类型转换）

（2）创建数组存储链表的节点值。（4）利用尾插法生成链表。（3）对数组进行排序。

s1 前 i 个字符 (s1[0…i-1])和 s2 前 j 个字符 (s2[0…j-1])，能匹配（不删除）的字符的 ASCII 总和的最大值。（1）在下标为[1, m - 1]的字符串s1 = “ea” 与 下标为[0, n - 1]的字符串s2 = "eat"中 寻找 相等的字符串。定义dp数组，多开一行一列存储空字符串。sum存的是两个字符串的ascii码值。（3）遍历顺序，从第二行第二列开始遍历。（2）初始化 第一行第一列默认是0。