zsysingapore的博客

限制：时间复杂度为 O(log n)，所以不能用遍历，必须使用 二分查找！二分查找：搜索区间必须是“单调有序”的（即 单调递增 或 单调递减）。输出：target 在 nums 中的下标，如果不存在，返回 -1。输入：旋转后的数组 nums，和一个整数 target。（1）首先翻转后的数组，构成两个有序数组。（2）对第一个有序数组进行二分查找。（3）对第二个有序数组进行二分查找。

【代码】2025年- H62-Lc170--34.在排序数组中查找元素的第一个和最后一个位置(二分查找）--Java版。

定义其实坐标，右上角的元素（0，n-1）。进入while循环（注意边界条件，行数小于m，列数要＞=0）从右上角开始开始向左遍历（比当前元素target小的元素），向下遍历（比当前元素target大的元素），如果while循环结束都没找到，返回false。若将矩阵每一行拼接在上一行的末尾，则会得到一个升序数组，我们可以在该数组上二分找到目标元素。可以二分升序数组的下标，将其映射到原矩阵的行和列上。col = mid % 列数，表示这是该行中的第几个元素。row = mid / 列数，表示这是第几行；

【代码】2025年- H60-Lc168--35.搜索插入的位置(二分查找）--Java版。

（3）统计完每个节点的入度，使用广度优先搜索。因为入度为0，说明没有先修课程，也就是先修课程已经完成了。如果c1已经修完，C3和C8以C1为先修课程，所以入度就可以-1.（1）如果有向图中的拓扑图中存在环，则说明所有的课程是无法完成的。记录每门课程的前置课程数量，记录每门课程是哪些课程的前置课程。最后要判断优秀，已学习的课程的数量是否等于输入课程的数量。（2）使用拓扑排序，在图中每个节点的入度和出度。将入度为0的课程加入到待学习的课程中。

如果 searchPrefix(word) 返回的节点不为 null，并且 node.isEnd == true，说明这个单词完整存在于 Trie 中。如果是前缀但不是完整单词（即 isEnd == false），则返回 false。调用辅助方法 searchPrefix(String prefix)目的：找到这个 word 对应的最后一个字符所在的节点。如果遍历过程中某个字符没有对应的子节点，返回 null。检查返回的节点是否有效。

【代码】2025年- H57-Lc165--994.腐烂的橘子(图论,广搜）--Java版。

（3）辅助函数，用递归（深搜），遍历以已访问过的元素（陆地1）的相邻元素（陆地1）。（2）主函数，visit数组表示已访问过的元素。（1）主函数，存储图结构。（1）确定递归函数和参数。补充：深度搜索（递归）

（1）至少要包含一个节点。所以就是以当前节点为根节点的左右孩子。（2）一个节点不能经过两次，子树（左右孩子）的和交给递归去做。递归过程，找到maxsum=max（maxsum，sum）递归返回结果：output=自己+max（左，右）递归公式：sum=自己+左+右。

求不同路径，用递归，当然递归里面包括前中后的遍历。我们采用前序遍历（根左右），从父节点到孩子节点。对每个节点作为起点，查找从它往下延伸的路径，是否有路径和等于 targetSum。外层 pathSum() 是遍历每一个节点（作为路径起点）；内层 rootSum() 是从当前节点往下查路径和。

2)而中序遍历的形式总是[ [左子树的中序遍历结果], 根节点, [右子树的中序遍历结果] ].只要我们在中序遍历中定位到根节点，那么我们就可以分别知道左子树和右子树中的节点数目。这样以来，我们就知道了左子树的前序遍历和中序遍历结果，以及右子树的前序遍历和中序遍历结果，我们就可以递归地对构造出左子树和右子树，再将这两颗子树接到根节点的左右位置。（4）左子树的根节点在前序遍历中紧跟当前根节点的位置（root + 1），其在中序遍历中的范围是 [left, i-1]。

返回一个从右侧看二叉树时能看到的所有节点的值。右视图中的每一层只能看到最右边的节点。可以使用 层序遍历（BFS），每次遍历一层时，记录该层的最后一个节点的值。

(5)特殊情况，当翻转部分长度不足 k 时，在定位 end 完成后，end==null，已经到达末尾，说明题目已完成，直接返回即可。(3)初始需要两个变量 pre 和 end，pre 代表待翻转链表的前驱，end 代表待翻转链表的末尾。(4)经过k此循环，end 到达末尾，记录待翻转链表的后继 next = end.next。翻转链表，然后将三部分链表连接起来，然后重置 pre 和 end 指针，然后进入下一次循环。(2)需记录翻转链表前驱和后继，方便翻转完成后把已翻转部分和未翻转部分连接起来。

二叉树的中序遍历即按照访问左子树——根结点——右子树的方式遍历二叉树；在访问其左子树和右子树时，我们也按照同样的方式遍历；先对二叉树进行一次完整遍历，将所有节点存入列表中，最后对列表排序后返回目标值。树的遍历可以使用 DFS 或 BFS。在二叉搜索树中，任意子节点都满足“左子节点 < 根节点 < 右子节点”的规则。所有左子树和右子树自身必须也是二叉搜索树。结点的左子树只包含小于当前结点的数。结点的右子树只包含大于当前结点的数。树的前序遍历 + 排序。方法二：(前序+排序）

（1） 如果当前节点为 null，或者等于 p 或 q，直接返回。应该返回 root，因为找到了 p 或 q，不能返回 null。（4） 如果左右子树都找到了，说明 p 和 q 分别在左右子树中，当前节点是最近公共祖先。如果当前节点是 p 或 q，就返回它（因为从这里可以回溯寻找公共祖先）。如果当前节点 root 为 null，表示到达了叶子节点的空子树；（6）否则返回右子树的结果（可能是 null 或找到的节点）（2） 在左子树中查找 p 和 q。（3）在右子树中查找 p 和 q。

（1）你可以不断往里面 .add(…) 数据，也可以用 .get(i) 访问特定位置的元素。它在遍历、存储树每一层的节点时非常好用。new ArrayList<>() 就是创建一个可以装元素的“动态袋子”。进了A分支就不会去B分支，去了B分支就不会去A分支。else if（B分支）（2）if（A分支）

Depth() 返回的是深度（从当前节点到底部的边数），而不是节点数。如果你返回节点数，就要额外处理 -1。径定义为“路径经过的节点数 - 1”，而递归中我们实际是在统计“边数”。left + right 就已经是边数，无需再减 1。

如果将 pre 定义在 isValidBST 方法内部，它是一个 局部变量，在每次递归调用时都会重新初始化为 null，因此 中序遍历中的“前一个节点”状态无法保存，从而导致判断失效。所以要把pre设置成类的成员变量，这样才能在递归调用之间保持它的状态（即保存上一个访问的节点）。类的内部状态（像 pre 这种中间变量）一般应该被保护（private），避免外部代码直接修改，导致不可预测的错误。// 用于记录中序遍历中上一个节点。

找到中间节点之后，根节点左边元素和右边元素都是闭区间。BST：二叉搜索树（Binary Search Tree）中序遍历，总是选择中间位置左边的数字作为根节点。

1.如果根节点为空，则炜对称二叉树。5. 左右不为空，但是值不相等。6. 左右不为空，但是值相等。（1）外侧的值等于外侧。（2）内侧的值等于内测。2.左为空，右不为空。3.右有空，左不为空。

（2）put（），首先如果新加入的元素在哈希表中不存在，则直接创建新节点加入到map中。如果双向链表的节点数超过链表容量，则剔除尾部节点（包括它的值）。如果新加入的元素存在（key存在），我们通过get进行定位，把节点值进行更新，移动到头部（说明是最近刚被访问的）（3）get（），如果get（key）不存在直接返回-1，如果key存在，说明key节点是最近被使用的节点。通过哈希表定位到双向链表的位置，并将其移动到双向链表的头部，返回该节点的值。链表头部是最近刚使用过的元素，尾部是最近不经常使用的元素。

我的理解是拷贝就说把第二个数往前移动1格，以此类推，后往前移动一格。

【代码】2025年- H40-Lc148 --155.最小栈（辅助栈）--Java版。

数字（循环的次数），然后把当前的字符串追加在可变的字符串temp中。temp.append(curString），循环完了之后，将可变字符串temp变成字符串temp.toString();首先先创建一个双栈，一个栈存数字（interger），另一个栈存字符（character）。设置数字临时变量num，设置字母临时变量curString在字符串中，我们会遇到左括号[,右括号]，数字，字母。（2）遇到左括号，把当前的数字和字母入栈，再将临时变量num和curstring置为0和空.

当 fast 指针走到 f=a 步时，slow 指针走到 s=a+nb 步。此时两指针重合，并同时指向链表环入口，返回 slow 指向的节点即可。此时 f=0，s=nb。快慢指针（fast 每次走 2 步，slow 走 1 步）；设两指针 fast，slow 指向链表头部 head。令 fast 每轮走 2 步，slow 每轮走 1 步。（1）在本题的求解过程中，双指针会产生两次“相遇”。两指针：一个从头走，一个从相遇点走，每次走一步；如果 fast == slow，说明有环；第二步：找环的起始节点。

2)如果满足了当前遍历的元素大于栈顶元素（也就是中间的mid元素），栈顶元素出栈，接下来mid的右边第一个元素成为栈顶元素。1）维护一个单调递增的栈，当前遍历的元素和栈顶元素进行比较（要求遍历的元素要大于栈顶元素），否则，就将当前遍历的元素入栈。4)计算容器的宽度,此处要-1。（比如横坐标是3，4，5。这边的1就是凹槽的宽度。（1）方法一：用双指针实现。（2）方法二：用单调栈实现。

（3）单调栈存储元素的索引。如果遇到比当前遍历元素小的元素（或者等于当前元素的元素）直接加入到栈中。否则，开始比较当前遍历元素和栈顶元素的大小（要求当前遍历元素大于栈顶元素）（2）因为要求找到当前元素 右边区域，第一个比当前元素大的元素，所以取单调增数量。（1）单调栈维护单调递增或者单调递减的数列。

因为左右括号匹配，说明是偶数个括号，可以用%2进行判断。(1)左右括号类型不匹配。

本问题其实常规解法可以分成多个子问题，爬第n阶楼梯的方法数量，等于 2 部分之和。所以我们得到公式 dp[n]=dp[n−1]+dp[n−2]爬上 n−1 阶楼梯的方法数量。因为再爬1阶就能到第n阶。爬上 n−2 阶楼梯的方法数量，因为再爬2阶就能到第n阶。同时需要初始化 dp[0]=1 和 dp[1]=1。

（8）如果最后一位还有进位，carry=1，说明要创建一个新节点用来保存进位值，然后curr指针指向这个新节点。（5）创建一个新节点tmp，用来保留sum（当前值），然后把cur指针指向tmp。（1）创建虚拟头节点，指向虚拟头节点的指针cur，进位（初始值为0）（7）如果l1为空，那么l2后移一位；如果l2为空，那么l1后移。（4）取余sum=sum%10，得到当前值（需要保留的值）（2）如果l1或者l2不为空，开始进行取值计算。（3）然后用carry=sum/10取得进位。（6）cur指针后移。

时间空间复杂度分别为 O(nlogn) 和 O(1)，根据时间复杂度想到二分法，从而联想到归并排序；（7）合并链表的时候，如果左右链表不均匀，就把剩余的一个节点直接补齐到链表上。（3）当快指针不等于null，以及快指针的下一节点不为空，快2慢1。（6）进行归并排序，左链表和右链表都不为空，实现链表的升序排序。（4） 左半部分的链表的头节点，右边部分的头节点。（5）创建虚拟头节点，以及指向头节点的指针pre。（1）空节点或者1个节点的情况，直接返回头节点。（2）创建两个快慢指针，快指针比慢指针多走一步。

(2)比较l1和l2值得大小，如果l1小，就把指针指向l1（pre.next=l1），同时list指针要向后移list1=list1.next；如果l2小，就把指针指向l2（pre.next=l2）；null，说明l1还有元素，把此时的pre指针指向l1，比如pre.next=l1。(1)定义一个虚拟的头节点，然后pre指针刚开始赋值要等于这个虚拟头节点。(3) 指针后移pre=pre.next;(4)如果链表的大小不一样。

（3）再判断左右部分的元素，是否相等。如果相等，则是回文字符串。（2）右半部分的元素进行反转链表，能达到O（1）的空间复杂度。（1）将链表取中位数，分为左右两部分。

弗洛伊德算法（快慢指针。

（6）要交换节点3和节点4的时候，要把curr从节点1移动到节点3，所以就要执行curr=curr.next.next。（5）在赋值操作之前，也需要定义一个临时变量，保存节点3（curr.next.next.next）（3）如果是0个节点。curr指向的是虚拟头节点，所以也满足curr.next=null。（4）在赋值操作之前，定义一个临时变量，保存节点1（curr.next）先判断偶数个节点，再判断奇数个节点，否则会犯空指针异常。（1）如果节点是偶数个节点，只要满足curr.next。

（1）双端队列可以移除最左边的元素，也可以移除最右边的元素（两端移除）（3）队列单调性（保持队列是单调递减）（2）在最右边插入元素（右边加入）

1.用集合做差集、并集（共同关注）、交集。

1.List可以当栈，队列，阻塞队列。

setnx（set if not exist）：不存在设置（分布式锁中常常会使用）getset db mongodb #如果存在值，获取原来的值，并设置新的值。#获取全部的字符串，和get key的命令一样，输出”hello，Lisa"#同时获取多个值，会返回1）"v1” 2）"v2” 3）“v3”#如果mykey不存在，创建mykey，返回1（创建成功）#追加字符串，如果当前key不存在，就相当于setkey。#如果mykey存在，创建失败，返回0（创建失败）

从根节点开始，递归地对树进行遍历，并从叶子节点先开始翻转。如果当前遍历到的节点 root 的左右两棵子树都已经翻转，那么我们只需要交换两棵子树的位置，即可完成以 root 为根节点的整棵子树的翻转。递归调用左右子树，就是调换左右子树的值。每个节点调换左右子树。