weixin_48683410的博客

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路层序遍历 + 双端队列利用双端队列的两端皆可添加元素的特性，设打印列表（双端队列） tmp ，并规定：奇数层 则添加至 tmp 尾部 ，偶数层 则添加至 tmp 头部 。算法流程：1.特例处理： 当树的根节点为空，则直接返回空列表 [] ；2.初始化： 打印结果空列表 res ，包含根节点的双端队列 deque ；3.BFS 循环： 当 deque 为空时跳出；1.新建列表 tmp ，用于临时存储当前层打印结果；2

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路1.将 101112⋯ 中的每一位称为 数位 ，记为 n ；2.将 10,11,12,⋯ 称为 数字 ，记为 num ；3.数字 10 是一个两位数，称此数字的 位数 为 2 ，记为 digit ；4.每 digit 位数的起始数字（即：1,10,100,⋯），记为 start 。观察上表，可推出各 digit 下的数位数量 count 的计算公式：count=9×start×digit根据以上分析，可将求解分为三步：

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路I. 按层打印：题目要求的二叉树的从上至下打印（即按层打印），又称为二叉树的广度优先搜索（BFS）。BFS通常借助队列的先入先出特性来实现。II. 每层打印到一行：将本层全部节点打印到一行，并将下一层全部节点加入队列，以此类推，即可分为多行打印。算法流程：1.特例处理：当根节点为空，则返回空列表 [] ；2.初始化： 打印结果列表 res = [] ，包含根节点的队列 queue = [root] ；3.BFS 循环： 当

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路题目要求的二叉树的从上至下打印（即按层打印），又称为二叉树的广度优先搜索（BFS）。BFS通常借助队列的先入先出特性来实现。算法流程：特例处理： 当树的根节点为空，则直接返回空列表 [] ；初始化： 打印结果列表 res = [] ，包含根节点的队列 queue = [root] ；BFS 循环： 当队列 queue 为空时跳出；出队： 队首元素出队，记为 node；打印： 将 node.val 添加至列表 tmp 尾

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路如果将数组 nums 中的所有元素按照单调递增或单调递减的顺序排序，那么下标为⌊n/2⌋的元素（下标从 0 开始）一定是众数。对于这种算法，我们先将 nums 数组排序，然后返回上文所说的下标对应的元素。下面的图中解释了为什么这种策略是有效的。在下图中，第一个例子是 n 为奇数的情况，第二个例子是 n 为偶数的情况。对于每种情况，数组下面的线表示如果众数是数组中的最小值时覆盖的下标，数组下面的线表示如果众数是数组中的最大值时

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路我们将这个问题看作有 n 个排列成一行的空位，我们需要从左往右依次填入题目给定的 n 个字符，每个字符只能使用一次。首先可以想到穷举的算法，即从左往右每一个空位都依次尝试填入一个字符，看是否能填完这 n 个空位，编程实现时，我们可以用「回溯法」来模拟这个过程。定义递归函数 backtrack(i,perm) 表示当前排列为 perm，下一个待填入的空位是第 i 个空位（下标从 0 开始）。那么该递归函数分为两个情况：如果 i=n

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路如下图所示，给定一个压入序列 pushed 和弹出序列 popped ，则压入 / 弹出操作的顺序（即排列）是 唯一确定 的。如下图所示，栈的数据操作具有 先入后出 的特性，因此某些弹出序列是无法实现的。考虑借用一个辅助栈 stack ，模拟 压入 / 弹出操作的排列。根据是否模拟成功，即可得到结果。入栈操作： 按照压栈序列的顺序执行。出栈操作： 每次入栈后，循环判断 “栈顶元素 == 弹出序列的当前元素” 是否成立，将

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路本文解法基于性质：二叉搜索树的中序遍历为递增序列 。将二叉搜索树转换成一个 “排序的循环双向链表” ，其中包含三个要素：1.排序链表： 节点应从小到大排序，因此应使用 中序遍历 “从小到大”访问树的节点。2.双向链表： 在构建相邻节点的引用关系时，设前驱节点 pre 和当前节点 cur ，不仅应构建 pre.right = cur ，也应构建 cur.left = pre 。3.循环链表： 设链表头节点 head 和尾节点

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路对原数组从小到大排序后取出前 k 个数即可。复杂度分析时间复杂度：O(nlogn)，其中 n 是数组 arr 的长度。算法的时间复杂度即排序的时间复杂度。空间复杂度：O(logn)，排序所需额外的空间复杂度为 O(logn)。3.代码实现class Solution { public int[] getLeastNumbers(int[] arr, int k) { int[] vec = new

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路本题删除值为 val 的节点需分为两步：定位节点、修改引用。1.定位节点： 遍历链表，直到 head.val == val 时跳出，即可定位目标节点。2.修改引用： 设节点 cur 的前驱节点为 pre ，后继节点为 cur.next ；则执行 pre.next = cur.next ，即可实现删除 cur 节点。算法流程：1.特例处理： 当应删除头节点 head 时，直接返回 head.next 即可。2.初始化： pr

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路方法一：迭代假设链表为 1→2→3→∅，我们想要把它改成 ∅←1←2←3。在遍历链表时，将当前节点的 next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。复杂度分析时间复杂度：O(n)，其中 n 是链表的长度。需要遍历链表一次。空间复杂度：O(1)。方法二：递归递归版本稍微复杂一些，其关键在于反向工作。假设链表的其余部分

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路解题思路：题目要求打印 “从 1 至最大的 n 位数的列表” ，因此需考虑以下两个问题：1.最大的 n 位数（记为 end ）和位数 n 的关系： 例如最大的 1 位数是 9 ，最大的 2 位数是 99 ，最大的 3 位数是 999 。则可推出公式：end = 10^n - 12.大数越界问题： 当 n 较大时，end 会超出 int32 整型的取值范围，超出取值范围的数字无法正常存储。但由于本题要求返回 int 类型数组，

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路方法一：顺序查找最简单直接的方法即为顺序查找，假设当前链表的长度为 n，则我们知道链表的倒数第 k 个节点即为正数第 n−k 个节点，此时我们只需要顺序遍历到链表的第 n−k 个节点即为倒数第 k 个节点。我们首先求出链表的长度 n，然后顺序遍历到链表的第 n−k 个节点返回即可。复杂度分析时间复杂度：O(n)，其中 n 为链表的长度。需要两次遍历。空间复杂度：O(1)。方法二：双指针快慢指针的思想。我们将第一个指针f

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路方法一：逐位判断根据 与运算 定义，设二进制数字 n ，则有：若 n&1=0 ，则 n 二进制 最右一位 为 0 ；若 n&1=1 ，则 n 二进制 最右一位 为 1 。根据以上特点，考虑以下 循环判断 ：判断 n 最右一位是否为 1 ，根据结果计数。将 n 右移一位（本题要求把数字 n 看作无符号数，因此使用 无符号右移 操作）。算法流程：1.初始化数量统计变量 res=0 。2.循环逐位判断：

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路此题与 面试题14- I. 剪绳子 主体等价，唯一不同在于本题目涉及 “大数越界情况下的求余问题” 。循环求余：根据求余运算性质推出（∵ 本题中 x<p，∴ x⊙p=x ）：x ^a ⊙p=[(x ^a−1⊙p)(x⊙p)]⊙p=[(x ^a−1⊙p)x]⊙p解析： 利用此公式，可通过循环操作依次求 x^1, x^2, …, x^a-1, x^a 对 p 的余数，保证每轮中间值 rem 都在 int32 取值范围中。封

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路设将长度为 n 的绳子切为 a 段：n=n1+n2+…+na​本题等价于求解：max(n1×n2 ×…×na)以下数学推导总体分为两步：① 当所有绳段长度相等时，乘积最大。② 最优的绳段长度为 3 。3.代码实现class Solution { public int cuttingRope(int n) { if(n <= 3) return n - 1; int a =

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路递推：定义 vis[i][j] 为 (i, j) 坐标是否可达，如果可达返回 1，否则返回 0。首先 (i, j) 本身需要可以进入，因此需要先判断 i 和 j 的数位之和是否大于 k ，如果大于的话直接设置 vis[i][j] 为不可达即可。否则，前面提到搜索方向只需朝下或朝右，因此 (i, j) 的格子只会从 (i - 1, j) 或者 (i, j - 1) 两个格子走过来（不考虑边界条件），那么 vis[i][j] 是否

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路本问题是典型的矩阵搜索问题，可使用 深度优先搜索（DFS）+ 剪枝 解决。深度优先搜索： 可以理解为暴力法遍历矩阵中所有字符串可能性。DFS 通过递归，先朝一个方向搜到底，再回溯至上个节点，沿另一个方向搜索，以此类推。剪枝： 在搜索中，遇到 这条路不可能和目标字符串匹配成功 的情况（例如：此矩阵元素和目标字符不同、此元素已被访问），则应立即返回，称之为 可行性剪枝 。DFS 解析：递归参数： 当前元素在矩阵 board 中

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路二分查找加暴力法混合使用：一个包含重复元素的升序数组在经过旋转之后，可以得到下面可视化的折线图：其中横轴表示数组元素的下标，纵轴表示数组元素的值。图中标出了最小值的位置，是我们需要旋转的目标。我们考虑数组中的最后一个元素 x：在最小值右侧的元素，它们的值一定都小于等于 x；而在最小值左侧的元素，它们的值一定都大于等于 x。因此，我们可以根据这一条性质，通过二分查找的方法找出最小值。在二分查找的每一步中，左边界为 low，右

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路此类求 多少种可能性 的题目一般都有 递推性质 ，即 f(n) 和 f(n−1)…f(1) 之间是有联系的。设跳上 n 级台阶有 f(n) 种跳法。在所有跳法中，青蛙的最后一步只有两种情况： 跳上 1 级或 2 级台阶。当为 1 级台阶： 剩 n−1 个台阶，此情况共有 f(n−1) 种跳法；当为 2 级台阶： 剩 n−2 个台阶，此情况共有 f(n−2) 种跳法。f(n) 为以上两种情况之和，即 f(n)=f(n−1)+f

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路动态规划：原理： 以斐波那契数列性质 f(n+1)=f(n)+f(n−1) 为转移方程。从计算效率、空间复杂度上看，动态规划是本题的最佳解法。动态规划解析：状态定义： 设 dp 为一维数组，其中 dp[i] 的值代表 斐波那契数列第 i 个数字 。转移方程： dp[i+1]=dp[i]+dp[i−1] ，即对应数列定义 f(n+1)=f(n)+f(n−1) ；初始状态： dp[0]=0, dp[1]=1 ，即初始化前两个

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路双栈：维护两个栈，第一个栈支持插入操作，第二个栈支持删除操作。根据栈先进后出的特性，我们每次往第一个栈里插入元素后，第一个栈的底部元素是最后插入的元素，第一个栈的顶部元素是下一个待删除的元素。为了维护队列先进先出的特性，我们引入第二个栈，用第二个栈维护待删除的元素，在执行删除操作的时候我们首先看下第二个栈是否为空。如果为空，我们将第一个栈里的元素一个个弹出插入到第二个栈里，这样第二个栈里元素的顺序就是待删除的元素的顺序，要执行删

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路栈：栈的特点是后进先出，即最后压入栈的元素最先弹出。考虑到栈的这一特点，使用栈将链表元素顺序倒置。从链表的头节点开始，依次将每个节点压入栈内，然后依次弹出栈内的元素并存储到数组中。创建一个栈，用于存储链表的节点创建一个指针，初始时指向链表的头节点当指针指向的元素非空时，重复下列操作：将指针指向的节点压入栈内将指针移到当前节点的下一个节点获得栈的大小 size，创建一个数组 print，其大小为 size创建下标并初始

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路字符数组：由于每次替换从 1 个字符变成 3 个字符，使用字符数组可方便地进行替换。建立字符数组地长度为 s 的长度的 3 倍，这样可保证字符数组可以容纳所有替换后的字符。获得 s 的长度 length创建字符数组 array，其长度为 length * 3初始化 size 为 0，size 表示替换后的字符串的长度从左到右遍历字符串 s获得 s 的当前字符 c如果字符 c 是空格，则令 array[size] = ‘

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路方法一：暴力如果不考虑二维数组排好序的特点，则直接遍历整个二维数组的每一个元素，判断目标值是否在二维数组中存在。依次遍历二维数组的每一行和每一列。如果找到一个元素等于目标值，则返回 true。如果遍历完毕仍未找到等于目标值的元素，则返回 false。复杂度分析时间复杂度：O(nm)。二维数组中的每个元素都被遍历，因此时间复杂度为二维数组的大小。空间复杂度：O(1)。方法二：线性查找由于给定的二维数组具备每行从左到右递增

文章目录1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路遍历数组：由于只需要找出数组中任意一个重复的数字，因此遍历数组，遇到重复的数字即返回。为了判断一个数字是否重复遇到，使用集合存储已经遇到的数字，如果遇到的一个数字已经在集合中，则当前的数字是重复数字。1.初始化集合为空集合，重复的数字 repeat = -12.遍历数组中的每个元素：将该元素加入集合中，判断是否添加成功如果添加失败，说明该元素已经在集合中，因此该元素是重复元素，将该元素的值赋给 repeat，并结束遍历，返回

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路方法 1：循环和位移动遍历数字的 32 位。如果某一位是 1 ，将计数器加一。我们使用 位掩码 来检查数字的第 i 位。一开始，掩码 m=1 因为 1 的二进制表示是0000 0000 0000 0000 0000 0000 0000 0001显然，任何数字跟掩码 1 进行逻辑与运算，都可以让我们获得这个数字的最低位。检查下一位时，我们将掩码左移一位。0000 0000 0000 0000 0000 0000 000

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路标签：字符串遍历，进制转换初始化结果 ans = 0，遍历时将每个字母与 A 做减法，因为 A 表示 1，所以减法后需要每个数加 1，计算其代表的数值 num = 字母 - ‘A’ + 1因为有 26 个字母，所以相当于 26 进制，每 26 个数则向前进一位所以每遍历一位则ans = ans * 26 + num以 ZY 为例，Z 的值为 26，Y 的值为 25，则结果为 26 * 26 + 25=701时间复杂度

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路方法一：哈希表最容易想到的方法是遍历所有节点，每次遍历到一个节点时，判断该节点此前是否被访问过。具体地，我们可以使用哈希表来存储所有已经访问过的节点。每次我们到达一个节点，如果该节点已经存在于哈希表中，则说明该链表是环形链表，否则就将该节点加入哈希表中。重复这一过程，直到我们遍历完整个链表即可。方法二：快慢指针(双指针法)可以使用快慢指针法， 分别定义 fast 和 slow指针，从头结点出发，fast指针每次移动两个

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路方法一：二分查找在数组中找到两个数，使得它们的和等于目标值，先固定第一个数，然后寻找第二个数，第二个数等于目标值减去第一个数的差。由于数组有序性质，可以通过二分查找的方法寻找第二个数。为了避免重复寻找，在寻找第二个数时，只在第一个数的右侧寻找。时间复杂度：O(nlogn)，其中 n 是数组的长度。空间复杂度：O(1)。方法二：双指针初始时两个指针分别指向第一个元素位置和最后一个元素的位置。每次计算两个指针指向的两个元

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路如果两个链表相交，那么相交点之后的长度是相同的我们需要做的事情是，让两个链表从同距离末尾同等距离的位置开始遍历。这个位置只能是较短链表的头结点位置。为此，我们必须消除两个链表的长度差1.指针 pA 指向 A 链表，指针 pB 指向 B 链表，依次往后遍历2.如果 pA 到了末尾，则 pA = headB 继续遍历3.如果 pB 到了末尾，则 pB = headA 继续遍历4.比较长的链表指针指向较短链表head时，

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路位运算：如果不考虑时间复杂度和空间复杂度的限制，这道题有很多种解法，可能的解法有如下几种。使用集合存储数字。遍历数组中的每个数字，如果集合中没有该数字，则将该数字加入集合，如果集合中已经有该数字，则将该数字从集合中删除，最后剩下的数字就是只出现一次的数字。使用哈希表存储每个数字和该数字出现的次数。遍历数组即可得到每个数字出现的次数，并更新哈希表，最后遍历哈希表，得到只出现一次的数字。使用集合存储数组中出现的所有数字，并

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路我们直接在原字符串 s 上使用双指针。在移动任意一个指针时，需要不断地向另一指针的方向移动，直到遇到一个字母或数字字符，或者两指针重合为止。也就是说，我们每次将指针移到下一个字母字符或数字字符，再判断这两个指针指向的字符是否相同。复杂度分析时间复杂度：O(∣s∣)，其中 ∣s∣ 是字符串 s 的长度。空间复杂度：O(1)。3.代码实现class Solution { public boolean isPali

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路贪心算法3.代码实现class Solution { public int maxProfit(int[] prices) { int ans = 0; int n = prices.length; for (int i = 1; i < n; ++i) { ans += Math.max(0, prices[i] - prices[i

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路方法一：暴力法我们需要找出给定数组中两个数字之间的最大差值（即，最大利润）。此外，第二个数字（卖出价格）必须大于第一个数字（买入价格）。形式上，对于每组 i 和 j（其中 j > i）我们需要找出max(prices[j]−prices[i])。复杂度分析时间复杂度：O(n^2)。循环运行n(n−1)/2次。空间复杂度：O(1)。只使用了常数个变量。方法二：一次遍历假设给定的数组为：[7, 1, 5, 3,

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路3.代码实现class Solution { public List<Integer> getRow(int rowIndex) { List<List<Integer>> C = new ArrayList<List<Integer>>(); for (int i = 0; i <= rowIndex; ++i) {

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路3.代码实现class Solution { public List<List<Integer>> generate(int numRows) { List<List<Integer>> ret = new ArrayList<List<Integer>>(); for (int i = 0; i < nu

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路方法一：广度优先搜索首先我们可以想到使用广度优先搜索的方式，记录从根节点到当前节点的路径和，以防止重复计算。这样我们使用两个队列，分别存储将要遍历的节点，以及根节点到这些节点的路径和即可。复杂度分析时间复杂度：O(N)，其中 N 是树的节点数。对每个节点访问一次。空间复杂度：O(N)，其中 N 是树的节点数。空间复杂度主要取决于队列的开销，队列中的元素个数不会超过树的节点数。方法二：递归观察要求我们完成的函数，我

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路深度优先搜索首先可以想到使用深度优先搜索的方法，遍历整棵树，记录最小深度。对于每一个非叶子节点，我们只需要分别计算其左右子树的最小叶子节点深度。这样就将一个大问题转化为了小问题，可以递归地解决该问题。3.代码实现class Solution { public int minDepth(TreeNode root) { if (root == null) { return

这里写目录标题1.题目描述2.解题思路3.代码实现1.题目描述2.解题思路自底向上的递归如果使用自底向上的做法，则对于每个节点，函数height 只会被调用一次。自底向上递归的做法类似于后序遍历，对于当前遍历到的节点，先递归地判断其左右子树是否平衡，再判断以当前节点为根的子树是否平衡。如果一棵子树是平衡的，则返回其高度（高度一定是非负整数），否则返回−1。如果存在一棵子树不平衡，则整个二叉树一定不平衡。复杂度分析时间复杂度：O(n)，其中 n 是二叉树中的节点个数。使用自底向上的递归，每个节