qq_51906990的博客

每次将链表拆分成若干个长度为 subLength 的子链表（最后一个子链表的长度可以小于 subLength）按照每两个子链表一组进行合并，合并后即可得到若干个长度为subLength×2 的有序子链表（最后一个子链表的长度可以小于 subLength×2）。合并两个子链表仍然使用[合并两个有序链表]的做法。寻找链表的中点可以使用快慢指针的做法，快指针每次移动 2 步，慢指针每次移动 1 步，当快指针到达链表末尾时，慢指针指向的链表节点即为链表的中点。3.将两个排序后的子链表合并，得到完整的排序后的链表。

一个巧妙的思路是，把lists一分为二（尽量均分），先合并前一半的链表，再合并后一半的链表，然后把这两个链表合并成最终的链表。如此分下去直到只有一个链表，此时无需合并。维护当前每个链表没有被合并的元素的最前面一个，k个链表就最多有k个满足这样条件的元素，每次在这些元素里面选取val属性最小的元素合并到答案中。给定一个链表数组，每个链表都已经按升序排序，请将所有链表合并到一个升序链表中，返回合并后的链表。按照方法一先合并前两个链表，再把得到的新链表和第三个链表合并，再和第四个链表合并，依此类推。

因此可以用「深度优先搜索」的方法来计算二叉树的最大深度。具体而言，在计算当前二叉树的最大深度时，可以先递归计算出其左子树和右子树的最大深度，然后在O(1)时间内计算出当前二叉树的最大深度。广度优先搜索的队列里存放的是「当前层的所有节点」。每次拓展下一层的时候，用一个变量ans来维护拓展的次数，该二叉树的最大深度即为ans。知道了左子树和右子树的最大深度l和r，那么该二叉树的最大深度即为:max(l,r)+1。每个节点在递归中只被遍历一次。二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。

如果链表中至少有两个节点，则在两两交换链表中的节点之后，原始链表的头节点变成新的链表的第二个节点，原始链表的第二个节点变成新的链表的头节点。用 head 表示原始链表的头节点，新的链表的第二个节点，用 newHead 表示新的链表的头节点，原始链表的第二个节点，则原始链表中的其余节点的头节点是 newHead.next。两两交换链表中的节点之后，新的链表的头节点是 dummyHead.next，返回新的链表的头节点即可。递归的终止条件是链表中没有节点，或者链表中只有一个节点，此时无法进行交换。

根据栈「先进后出」的原则，我们弹出栈的第 n 个节点就是需要删除的节点，并且目前栈顶的节点就是待删除节点的前驱节点。首先从头节点开始对链表进行一次遍历，得到链表的长度 L，随后再从头节点开始对链表进行一次遍历，当遍历到第 L−n+1 个节点时，它就是我们需要删除的节点。在对链表进行操作时，常用的技巧是添加一个哑节点（dummy node），它的 next 指针指向链表的头节点，就不需要对头节点进行特殊的判断。与题目中的 n 保持一致，节点的编号从 1 开始，头节点为编号 1 的节点。时间复杂度：O(N)

如果当前两个链表处相应位置的数字为n1,n2,进位为carry,则它们的和为n1+n2+carry。答案链表处相应位置的数字为 (n1+n2+carry)mod10，而新的进位值为(n1+n2+carry)//10。这里的技巧是，创建一个哨兵节点（dummy node），当成初始的「空链表」。由于输入的两个链表都是逆序(链表顺序反向)存储数字的位数的，因此两个链表中同一位置的数字是可以直接相加。此外，如果链表遍历结束后，有carry>0,还需要在答案后面附加一个节点，节点值为carry。

例如链表 1→2→3，依次复制每个节点（创建新节点并复制 val 和 next），把新节点直接插到原节点的后面，形成一个交错链表：1→1 ′→2→2 ′ →3→3 ′ 如此一来，原链表节点的下一个节点，就是其对应的新链表节点了！复制链表中的指针都不应指向原链表中的节点。一个可行方案是，利用回溯的方式，让每个节点的拷贝操作相互独立，对于当前节点，首先要进行拷贝，然后我们「当前节点的后继节点」和「当前节点的随机指针指向的节点」拷贝，拷贝完成后将创建的新节点的指针返回，即可完成当前节点的两指针的赋值。

从根节点开始，递归地对树进行遍历，并从叶子节点先开始翻转。如果当前遍历到的节点root的左右两棵子树都已经翻转，那么我们只需要交换两棵子树的位置，即可完成以root为根节点的整棵子树的翻转。给定一颗二叉树的根节点root,翻转这棵二叉树，并返回根节点。时间复杂度：O(n)遍历二叉树中的每一个节点。空间复杂度：O(n)

但是对于一个子链表，除了翻转其本身之外，还需要将子链表的头部与上一个子链表连接，以及子链表的尾部与下一个子链表连接。K是正整数，它的值小于等于链表的长度，如果节点总数不是K的整数组，那么将最后剩余的节点保持原有顺序。不能只改变节点内容的值，需要进行实际的节点交换。给定链表的头节点head,每K个节点一组进行翻转，返回修改后的链表。步，直至链表结尾，对于每个分组，我们先判断它的长度是否大于等于。的，们新建一个节点，把它接到链表的头部，让它作为。在翻转子链表的时候，我们不仅需要子链表头节点。

给定一个二叉树的根节点root,返回它的中序遍历。二叉树的中序遍历：按照访问左子树——根节点——右子树的方式遍历这棵树，而在访问左子树或者右子树的时候我们按照同样的方式遍历，直到遍历完整棵树。因此整个遍历过程天然具有递归的性质。

由于输入的两个链表都是有序的，所有不管哪个链表是非空的，它包含的所有元素都比前面已经合并链表中的所有元素都要大，所以，只需要简单地将非空链表接在合并链表地后面，并返回合并链表即可。否则要判断L1和l2哪一个链表的头节点的值更小，然后递归的决定下一个添加结果里的节点，如果两个链表有一个为空，递归结束。当l1和l2都不是空链表时，判l1和l2哪一个链表的头节点的值更小，将较小值得节点添加到结果里，当一个节点被添加到结果里之后，将对应链表中得节点向后移动一位。新链表是通过拼接给定的两个链表的所有节点组成的。

b，则指针 pA 会遍历完链表 headA，指针 pB 会遍历完链表 headB，两个指针不会同时到达链表的尾节点，然后指针 pA 移到链表 headB 的头节点，指针 pB 移到链表 headA 的头节点，然后两个指针继续移动，在指针 pA 移动了 a+c+b 次、指针 pB 移动了 b+c+a 次之后，两个指针会同时到达两个链表相交的节点，该节点也是两个指针第一次同时指向的节点，此时返回相交的节点。考虑当 m=n 和 m！如果 a=b，则两个指针会同时到达两个链表相交的节点，此时返回相交的节点；

此时，fast 指针已经走完了环的 n 圈，因此它走过的总距离为 a+n(b+c)+b=a+(n+1)b+nc。时间复杂度：O(N)在最初判断快慢指针是否相遇时，slow 指针走过的距离不会超过链表的总长度；因此，总的执行时间为 O(N)+O(N)=O(N)。有了 a=c+(n−1)(b+c) 的等量关系，发现：从相遇点到入环点的距离加上 n−1 圈的环长，恰好等于从链表头部到入环点的距离。因此，有a+(n+1)b+nc=2(a+b)⟹a=c+(n−1)(b+c)指针再次到达，则链表中存在环。

在遍历链表时，将当前节点的next指针改为指向前一个节点。由于节点没有引用其前一个节点，因此要先存储前一个节点，在更改引用之前，还要存储后一个节点，最后返回新的头引用。若从节点nk+1到nm已经被反转，而我们处于nk,n1​→…→nk−1​→nk​→nk+1​←…需要注意的是 n1​ 的下一个节点必须指向 ∅。假设链表为：n1​→…→nk−1​→nk​→nk+1​→…给单链表的头节点，反转链表，并返回反转后的链表。链表注意：上一个，现在，下一个的关系。空间复杂度：O(1)空间复杂度：O(N)

在起点放置一个指针，在结尾放置一个指针，每一次迭代判断两个指针指向的元素是否相同，若不同，返回 false；同样的方法在链表操作上并不简单，因为不论是正向访问还是反向访问都不是O(1).而将链表的值复制到数组列表中是O(n),因此简单的方法是将链表的值复制到数组列表中，再使用双指针法判断。（2）链表存储的是称为节点的对象，每个节点保存一个值和指向下一个节点的指针。（1）数组列表底层是使用数组存储值，可以通过索引在O(1)的时间访问列表任何位置的值，这是基于内存寻址的方式。算法：1找到前半部分链表的尾节点。

因此，可以假想一个head之前的虚拟节点，慢指针从虚拟节点移动一步到达head,快指针从虚拟节点移动两步到达head.next,这样可以使用while循环。如果链表中有某个节点，可以通过连续跟踪next指针再次到达，则链表中存在环。这样一来，如果在移动的过程中，快指针反过来追上慢指针，就说明该链表为环形链表。否则快指针将到达链表尾部，该链表不为环形链表。具体使用哈希表来存储访问过的节点，每次到达一个节点，如果该节点已经存在于哈希表中，则说明该链表是环形链表，否则就将该节点加入哈希表。空间复杂度：O(1)

对于矩阵的第一行而言，在旋转后，它出现在倒数第一列的位置，并且第一行的第x个元素在旋转后恰好是倒数第一列的第x个元素。使用一个与matrix大小相同的辅助数组matrixnew,临时存储旋转后的结果，遍历matrix中的每一个元素，根据规则将该元素放到martrixnew中对应的位置，在遍历完成后，再将matrix中的结果复制到原数组中即可。矩阵的行列从0开始计数，因此对于矩阵中的元素matrix[row][col],在旋转后，它的新位置为matrixnew[col][n-row-1]。

如果matrix[x,y]>target,由于每一列的元素都是升序排序的，那么在当前的搜素矩阵中，所有位于第y列的元素都是严格大于target的，因此可以将他们忽略，即将y-1。如果matrix[x,y]<target,由于每一行的元素都是升序排列的，那么在当前的搜索矩阵中，所有位于第行的元素都是严格小于target的，因此可以将x+1。时间复杂度：O(M+N).在搜索的过程中，没有找到 target，那要么将 y 减少 1，要么将 x 增加 1,最多为边界值的次数。空间复杂度：O(1)

以数组intervals表示若干区间的集合，其中单个区间为intervals[i]=[starti,endi]。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。（1）如果当前区间的左端点在数组merged中最后一个区间的右端点之后，那么它们不会重合，将这个区间加入数组merged的末尾。（2）否则重合，更新当前区间的右端点更新数组merged中最后一个区间的右端点，将其设置为二者的较大值。时间复杂度:O(nlogn)空间复杂度:O(logn)

使用矩阵的第一行和第一列代替方法一中的两个标记数组，以达到 O(1) 的额外空间。只使用一个标记变量记录第一列是否原本存在0，这样，第一列的第一个元素即可以标记第一行是否出现0。首先，遍历数组，如果某个元素为0，则将该元素所在的行和列对应标记数组的位置设为true,再次遍历该数组，用标记数组更新原数组。题目：给定一个mxn的矩阵，如果一个元素为0，则将其所在行和列的所有元素都设为0，请使用原地算法。时间复杂度：O(mn),m是矩阵的行数，n是矩阵的列数。使用两个标记数组分别记录每一行和每一列是否有零出现。

判断路径是否进入之前访问过的位置需要使用一个与输入矩阵大小相同的辅助矩阵visited,其中的每个元素表示该位置是否被访问过。由于矩阵中的每个元素都被访问一次，因此路径的长度即为矩阵中的元素数量，当路径的长度达到矩阵中的元素数量时即为完整路径，将该路径返回。模拟螺旋矩阵的路径。初始位置是矩阵的左上角，初始方向是向右，当路径超出界限或者进入之前访问过的位置时，顺时针旋转，进入下一个方向。时间复杂度：O(mn)空间复杂度：O(mn)时间复杂度：O(mn)空间复杂度：O(1)

空间复杂度:O(1)输出数组不算进空间复杂度中，只需要常数的空间存放变量。给一个整数数组nums,返回数组answer,其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。把answewr作为方法一种的L数组，不构造R数组，用一个遍历来跟踪右边元素的乘积，并更新answer数组。空间复杂度:O(n)使用了L和R存储前后缀去构造答案。时间复杂度:O(n)3轮循环。时间复杂度:O(n)

用n表示数组的长度，遍历原数组，将原数组下标为i的元素，放至新数组下标为(i+k)mod n 的位置，最后将新数组拷贝至原数组。先将所以元素翻转，这样尾部的k mod n个元素会移至数组头部,再翻转[0,kmod n-1]区间的元素和[k mod n,n-1]区间的元素即可。将数组元素向右移动k次后，尾部k mod n个元素会移至数组头部，其余元素向后移动k mod n个位置。时间复杂度:O(n)每个元素被翻转两次O(2n)=O(1)时间复杂度:O(n)，其中 n 为数组的长度。空间复杂度:O(n)

首先去除数组中无关的数，将数组中所有小于等于0的数和大于N的数修改为N+1,然后对数组进行遍历，对于遍历到的数X，如果它在[1,N]的范围内，那么将数组中的第x-1个位置打上标记（这里变为负数）在原数组打标记的目的是在常数空间内解决这个问题。数组恢复流程：可以对数组进行一次遍历，对于遍历到的数 x=nums[i]，如果 x∈[1,N]，知道 x 应当出现在数组中的 x−1 的位置，因此交换 nums[i] 和 nums[x−1]，这样 x 就出现在了正确的位置。为例，恢复后的数组应当为。

假设nums数组的长度是n，下标从0到n-1，用f(i)代表以第i个数结尾的连续子数组的最大和，答案即是max{f(i)}。只需要求出每个位置的f(i),然后返回f数组中的最大值即可。动态规划转移方程为：f(i)=max{f(i-1)+nums[i],nums[i]}给你一个整数组nums,找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。时间复杂度:O(n)只遍历了一次数组。空间复杂度:O(1)使用了常数空间。子数组是数组中的一个连续部分。

时间复杂度:O(C⋅∣s∣+∣t∣)最坏情况下左右指针对 s 的每个元素各遍历一遍，哈希表中对 s 中的每个元素各插入、删除一次，对 t 中的元素各插入一次。用哈希表表示t中所有的字符以及它们的个数，用一个哈希表动态维护窗口中所有的字符以及它们的个数，如果这个动态表中包含t的哈希表中的所有字符，并且对应的个数都不小于t的哈希表中各个字符的个数，那么当前窗口是可行的。如何判断s的子串包含了t中的所有字符——分别统计s的子串和t中每个字符出现的次数，然后逐个对比。称包含t的全部字母的窗口的可行窗口。

建立哈希表mp,以前缀和pre[i]为键，出现的次数为对应的值，记录pre[i]出现的次数，从左到右边更新mp边计算答案，那么以i结尾的答案mp[pre[i]-k]即可在O(1)时间内得到，最后的答案即为所有下标结尾和为k的子数组个数之和。定义前缀和数组pre使得pre[i]为nums[0],nums[i]中所有数的和，则pre[i]可以从pre[i-1]得到，即pre[i]=pre[i-1]+nums[i]给你一个整数数组nums和一个整数k,请你统计并返回该数组中和为k的子数组的个数。

求解滑动窗口的最大值，如果当前的滑动窗口有两个下标i和j,i小于j,并且对应的元素nums[i]<=nums[j]，当滑动窗口向右移动时i，只要i还在窗口中，那么j一定也还在窗口中，由于nums[j]的存在，nums[i]一定不会是滑动窗口的最大值，可以将其清除。当滑动窗口向右移动时，我么需要把一个新元素放入队列中，为了保持队列的性质，需要不断将元素与队尾的元素相比较，如果前者大于等于后者，那么队尾的元素就可以被永久地移除，将其弹出队列，需要不断地进行此项操作，直到队列为空或者新地元素小于队尾地元素。

时间复杂度：O(n+m+26)m 为字符串 p 的长度,需要 O(m) 来统计字符串 p 中每种字母的数量,需要 O(m) 来初始化滑动窗口,需要 O(26) 来初始化 differ；因为字符串p的异位词长度一定与字符串p的长度相同，所以可以在字符串s中构造一个长度为字符串p的长度相同的滑动窗口，并在滑动中维护窗口中每种字母的数量；时间复杂度:O(m+(n−m)*26)n 为字符串 s 的长度，m 为字符串 p 的长度，需要 O(m) 来统计字符串 p 中每种字母的数量；需要 O(m) 来初始化滑动窗口；

给定一个整数数组nums,判断是否存在三元组[nums[i],nums[j],nums[k]]满足i!=k,同时满足nums[i]+nums[j]+nums[k]==0。使用三重循环，分别找出第1，2，3个元素分别判断是否和为0。关键提示：不包含重复键；利用排序避免重复答案。注意：答案中不可以包含重复的三元组。运行可以通过，提交时会超出时间限制。空间复杂度：O(n3)时间复杂度:O(n3)时间复杂度：O(n2)空间复杂度：O(1)空间复杂度：O(1)空间复杂度：O(n)

从动态规划方法中注意到只要left_max_arr[i]>right_max_arr[i],积水的高度将由right_max_arr决定，同理，如果right_max_arr[i]>left_max_arr[i],积水的高度将由left_max_arr决定。对于下标i,下雨后水能到达的最大高度等于下标i两边的最大高度的最小值，下标i处能接的雨水量等于下标i处的水能到达的最大高度减去height[i]。从height[0]到当前位置寻找最大值left_max=max[height[j],left_max)。

假设选择字符串中的第k个字符作为起始位置，并且得到了不包含重复字符的最长子串的结束位置rk,那么当选择第k+1个字符作为起始位置时，首先从k+1到rk的字符显然是不重复的，并且由于少了原本的第k个字符，可以继续增大rk,直到右侧出现重复字符为止。在每一步的操作中，我们会将左指针向右移动一格，表示开始枚举下一个字符作为起始位置，然后不断地向右移动右指针，但需要保证这两个指针对应地子串中没有重复的字符。在移动结束后，这个子串就对应着以左指针开始的，不包含重复字符的最长子串，记录子串的长度。字符均为重复的情况；

在初始时，左右指针分别指向数组的左右两端，计算记录接纳的水量;移动对应数字较小的那个指针（即此时的左指针）。这是因为，由于容纳的水量是由两个指针指向的数字中较小值*指针之间的距离，如果移动数字较大的那个指针，那么前者【两个指针指向的数字中较小值】不会增加，后者【指针之间的距离】会减小，那么这个乘积会减小。因此，移动数字较大的那个指针是不合理的，因此，移动数字较小的那个指针。左右指针分别从两头出发，每次固定较长得那条边，短边指针向内移动，计算该边变长后得面积，同时决定是否交换移动顺序。空间复杂度:O(1)

使用双指针，左指针指向当前已经处理好的序列的尾部，右指针指向待处理序列的头部。右指针不断向右移动，每次右指针指向非零数，则将左右指针对应的数交换，同时左指针右移。算法通过一次遍历完成了所有操作，遍历数组中的每个元素一次，交换操作和指针移动都是常数时间操作。给定一个数组nums,编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序。因此每次交换，都是将左指针的零与右指针的非零数交换，且非零数的相对顺序并未改变。请注意，必须在不复制数组的情况下原地对数组进行操作。注意：左指针左边均为非零数。

如果已知有一个x,x+1,x+2,..x+y的连续序列，而我们却从x+1,x+2或者x+y开始匹配，那么得到的结果肯定不会优于枚举x为起点的答案，因此在外层循环时需要判断前驱x-1是否在数组中来跳过这种情况。考虑枚举数组中的每个数x,考虑以其为起点，不断尝试匹配x+1,x+2,...是否存在，假设最长匹配到了x+y，那么以x为起点的最长连续序列即为x,x+1,x+2,...x+y。给定一个未排序的整数数组nums,找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。set(num):将列表。

时间复杂度：O(nklogk)n是字符串的数目，k是字符串的最大长度，需要遍历n个字符串，每个字符串需要O(klogk)的时间进行排序以及O(1)的时间更新哈希表。互为字母异位分组的两个字符串包含的字母相同，因此两个字符串中的相同字母出现的次数一定是相同的，故可以将每个字母出现的次数使用字符串表示，作为哈希表的键。由于互为字母异位词的两个字符串包含的字母相同，因此，对于两个字符串分别进行排序之后得到的字符串一定是相同的，故可以将排序之后的字符串作为哈希表的键。空间复杂度：O(nk)

给定一个整数数组nums和一个整数目标值target,请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标。创建一个哈希表，对于每一个x,首先查询哈希表中是否存在target-x,然后将x插入哈希表中，即可保证不会让x和自己匹配。在遍历的同时，记录一些信息，以省去一层循环，以空间换时间，需要记录已经遍历过的数值和它所对应的下标，可以借助查表实现。时间复杂度：O(n)n是数组中元素数目，对于每一个元素x,可以O(1)的寻找target-x。空间复杂度：O(n)主要为哈希表的开销。