你好，世界
这是这个博客的第一篇文章，记录它为什么开始，以及接下来会写些什么。
LeetCode 第161题：相隔为1的编辑距离
给定两个字符串 s 和 t，判断他们的编辑距离是否为 1。 注意： - 满足编辑距离为 1 有三种可能的情形： - 往 s 中插入一个字符得到 t - 从 s 中删除一个字符得到 t - 在 s 中替换一个字符得到 t
LeetCode 第162题：寻找峰值
峰值元素是指其值严格大于左右相邻值的元素。 给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。 你可以假设 nums[-1] = nums[n] = -∞，并且对于所有有效的 i 都有 nums[i] != nums[i + 1]。换句话说，相邻元素的值都不相等。 你必须实现时间复杂度
LeetCode 第163题：缺失的区间
给定一个排序的整数数组 nums，其中元素的范围在闭区间 [lower, upper] 内，返回不包含在数组中的区间范围的列表。
LeetCode 第164题：最大间距
给定一个无序的数组 nums，返回 数组在排序之后，相邻元素之间最大的差值 。如果数组元素个数小于 2，则返回 0 。 您必须编写一个在「线性时间」内运行并使用「线性额外空间」的算法。
LeetCode 第165题：比较版本号
给你两个版本号 version1 和 version2，请你比较它们。 版本号由一个或多个修订号组成，各修订号由一个 '.' 连接。每个修订号由 多位数字 组成，可能包含 前导零。每个版本号至少包含一个字符。修订号从左到右编号，下标从 0 开始，最左边的修订号下标为 0，下一个修订号下标为 1，以此类推。例如，2.5.33 和 0.1 都是有效的版本号。 比
LeetCode 第166题：分数到小数
给定两个整数，分别表示分数的分子 numerator 和分母 denominator，以 字符串形式返回小数。 如果小数部分为循环小数，则将循环的部分括在括号内。 如果存在多个答案，只需返回 任意一个。 对于所有给定的输入，保证 答案字符串的长度小于 10^4。
LeetCode 第167题：两数之和 II - 输入有序数组
给你一个下标从 1 开始的整数数组 numbers，该数组已按 非递减顺序排列，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2]，则 1 <= index1 < index2 <= numbers.length。 以长度为 2 的整数数组 [index1,
LeetCode 第168题：Excel表列名称
给你一个整数 columnNumber，返回它在 Excel 表中相对应的列名称。 例如： A -> 1 B -> 2 C -> 3 ... Z -> 26 AA -> 27 AB -> 28 ...
LeetCode 第169题：多数元素
给定一个大小为 n 的数组 nums，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。 你可以假设数组是非空的，并且给定的数组总是存在多数元素。
LeetCode 第170题：两数之和 III - 数据结构设计
设计一个接受整数流的数据结构，并能够检查它们中是否有一对整数的和等于特定值。 实现 TwoSum 类： - TwoSum() 初始化 TwoSum 对象，使其为空 - void add(int number) 向数据结构添加一个数 number - boolean find(int value) 寻找数据结构中是否存在一对整数，它们的和等于 value。如果
LeetCode 151 反转字符串中的单词：双指针巧妙处理空格
给你一个字符串 s，请你反转字符串中 单词 的顺序。 单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。 返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。 注意：输入字符串 s 中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
LeetCode 152 乘积最大子数组：动态规划同时维护最大最小值
给你一个整数数组 nums，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。 测试用例的答案是一个 32-位 整数。 子数组 是数组的连续子序列。
LeetCode 153 寻找旋转排序数组中的最小值：二分查找的变种
已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到： - 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2] - 若旋转 7 次，则可以得到 [0,1,2,4,5,6,7] 注意，数组 [a[0], a[1], a[2], ...,
LeetCode 154 寻找旋转排序数组中的最小值II：处理重复元素
已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到： - 若旋转 4 次，则可以得到 [4,5,6,7,0,1,4] - 若旋转 7 次，则可以得到 [0,1,4,4,5,6,7] 注意，数组 [a[0], a[1], a[2], ...,
LeetCode 155 最小栈：辅助栈实现O(1)查询最小值
设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。 实现 MinStack 类: - MinStack() 初始化堆栈对象。 - void push(int val) 将元素val推入堆栈。 - void pop() 删除堆栈顶部的元素。 - int top() 获取堆栈顶部的元素。 - int getMin() 获取堆栈中的
LeetCode 156 上下翻转二叉树：递归巧妙改变树结构
给定一个二叉树，其中所有的右节点要么是具有兄弟节点（拥有相同父节点的左节点）的叶子节点，要么为空，将此二叉树上下翻转并将它变成一棵树，原来的右节点将转换成左叶子节点。返回新的根。
LeetCode 157 用Read4读取N个字符：API调用的模拟实现
给你一个文件，并且该文件只能通过给定的 read4 方法来读取，请实现一个方法来读取 n 个字符。 read4 方法： - API read4 可以从文件中读取 4 个连续的字符，并且将它们写入缓存数组 buf 中。 - 返回值为实际读取的字符个数。 注意：read4() 有自己的文件指针，就像 C 语言中的 FILE fp 一样。
LeetCode 158 用Read4读取N个字符II：多次调用的状态管理
给你一个文件，并且该文件只能通过给定的 read4 方法来读取，请实现一个方法来读取 n 个字符。 read4 方法： - API read4 可以从文件中读取 4 个连续的字符，并且将它们写入缓存数组 buf 中。 - 返回值为实际读取的字符个数。 注意：read4() 有自己的文件指针，就像 C 语言中的 FILE fp 一样。
LeetCode 159 至多包含两个不同字符的最长子串：滑动窗口经典题
给定一个字符串 s，找出 至多 包含两个不同字符的最长子串 t，并返回该子串的长度。
LeetCode 160 相交链表：双指针巧妙解法
给你两个单链表的头节点 headA 和 headB，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null。 图示两个链表在节点 c1 开始相交： A: a1 → a2 ↘ c1 → c2 → c3 ↗ B: b1 → b2 → b3 题目数据 保证 整个链式结构中不存在环。 注意，函数返回结果后，链表必须 保持其原始结构 。
LeetCode 143 重排链表：三步优化空间复杂度到O(1)
给定一个单链表 L 的头节点 head ，单链表 L 表示为： L0 → L1 → L2 → ... → Ln-1 → Ln 请将其重新排列后变为： L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → ... 不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
LeetCode 144 二叉树前序遍历：递归、迭代、Morris三种解法
给你二叉树的根节点 root ，返回它节点值的 前序遍历 。
LeetCode 145 二叉树后序遍历：递归和迭代巧妙实现
给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。
LeetCode 146 LRU缓存：哈希表+双向链表实现O(1)操作
请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： - LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 - int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 - void put(int key,
LeetCode 147 对链表进行插入排序：O(1)空间实现排序
给定单个链表的头节点 head ，使用 插入排序 对链表进行排序，并返回排序后链表的头节点。 插入排序 算法的步骤: 1. 插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。 2. 每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。 3. 重复直到所有输入数据插入完为止。
LeetCode 148 排序链表：归并排序实现O(nlogn)复杂度
给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。 进阶： - 你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？
LeetCode 149 直线上最多的点数：哈希表优化斜率计算
给定一个数组 points ，其中 points[i] = [xi, yi] 表示 X-Y 平面上的一个点，求最多有多少个点在同一条直线上。
LeetCode 150 逆波兰表达式求值：栈的经典应用
给你一个字符串数组 tokens，表示一个根据逆波兰表示法表示的算术表达式。 请你计算该表达式。返回一个表示表达式值的整数。 注意： - 有效的算符为 '+'、'-'、'' 和 '/' - 每个操作数（运算对象）都可以是一个整数或者另一个表达式 - 两个整数之间的除法总是向零截断 - 表达式中不含除零运算 - 输入是一个根据逆波兰表示法表示的算术表达式 -
LeetCode 第368题：最大整除子集
给你一个由无重复正整数组成的集合 nums，请你找出并返回其中最大的整除子集 answer，子集中每一对元素 (answer[i], answer[j]) 都应当满足： answer[i] % answer[j] == 0，或 answer[j] % answer[i] == 0 如果存在多个有效解子集，返回其中任何一个均可。
LeetCode 第369题：给单链表加一
给定一个用链表表示的非负整数，将这个整数加一。 链表中的每个节点表示一个数字，从最高位到最低位。
LeetCode 第370题：区间加法
假设你有一个长度为 n 的数组，初始情况下所有的数字均为 0，你将会被给出 k 个更新的操作。 其中，每个操作会被表示为一个三元组：[startIndex, endIndex, inc]，你需要将子数组 A[startIndex ... endIndex]（包括 startIndex 和 endIndex）增加 inc。 请你返回 k 次操作后的数组。
LeetCode 第364题：加权嵌套序列和II
给定一个嵌套的整数列表，实现一个迭代器来扁平化这个列表。 每个元素要么是一个整数，要么是一个列表 -- 其元素也可能是整数或其他列表。
LeetCode 第365题：水壶问题
有两个容量分别为 x升 和 y升 的水壶以及无限多的水。请判断能否通过使用这两个水壶，从而可以得到恰好 z升 的水？ 如果可以，最后请用以上水壶中的一或两个来盛放取得的 z升 水。 你允许： - 装满任意一个水壶 - 清空任意一个水壶 - 从一个水壶向另外一个水壶倒水，直到装满或者倒空
LeetCode 第366题：寻找二叉树的叶子节点
给你一棵二叉树，请按以下方式收集它的叶子节点： 1. 收集所有叶子节点 2. 删除所有叶子节点 3. 重复这个过程直到树为空
LeetCode 第367题：有效的完全平方数
给定一个正整数 num，编写一个函数，如果 num 是一个完全平方数，则返回 true，否则返回 false。 进阶： 不要使用任何内置的库函数，如 sqrt。
LeetCode 第403题：青蛙过河
一只青蛙想要过河。假定河流被等分为若干个单元格，并且在每一个单元格内都有可能放有一块石子（也有可能没有）。青蛙可以跳上石子，但是不可以跳入水中。 给你石子的位置列表 stones（用单元格序号 升序 表示），请判定青蛙能否成功过河（即能否在最后一步跳至最后一块石子上）。 开始时，青蛙默认已站在第一块石子上，并可以假定它第一步只能跳跃 1 个单位（即只能从单元
LeetCode 第307题：区域和检索 - 数组可修改
给你一个数组 nums，请你完成两类查询： 1. 更新 数组 nums 下标对应的值 2. 返回数组 nums 中索引 left 和 right 之间的和（包含 left 和 right） 实现 NumArray 类： - NumArray(int[] nums) 用整数数组 nums 初始化对象 - void update(int index, int v
LeetCode 第421题：数组中两个数的最大异或值
给你一个整数数组 nums ，返回 nums[i] XOR nums[j] 的最大运算结果，其中 0 ≤ i ≤ j < n 。
LeetCode 第422题：有效的单词方阵
给你一个单词序列，判断其是否形成了一个有效的单词方阵。 有效的单词方阵是指：从第 k 行和第 k 列读出的字符串应当相同，其中 0 ≤ k < max(numRows, numColumns)。 注意： 1. 给定的单词数量至少为 1，且不超过 500。 2. 每个单词的长度至少为 1，且不超过 500。 3. 每个单词只包含小写英文字母 a-z。
LeetCode 第423题：从英文中重建数字
给你一个字符串 s ，其中包含字母顺序打乱的用英文单词表示的若干数字（0-9）。按 升序 返回原始的数字。
LeetCode第424题：替换后的最长重复字符
给你一个字符串 s 和一个整数 k 。你可以选择字符串中的任一字符，并将其更改为任何其他大写英文字符。该操作最多可执行 k 次。 在执行上述操作后，返回包含相同字母的最长子串的长度。
LeetCode 第425题：单词方阵
给定一个单词集合 words，其中所有单词长度都相同。找出并返回其可以构成的所有单词方阵。 单词方阵是一个 n × n 的方阵，由单词集合中的单词构成，并满足： - 如果我们将这个方阵逐行读出，将会得到单词集合中的某些单词。 - 如果我们将这个方阵逐列读出，将会得到单词集合中的某些单词。
LeetCode 第426题：将二叉搜索树转化为排序的双向链表
将一个二叉搜索树就地转化为一个已排序的双向循环链表。可以将左右指针作为双向循环链表的前驱和后继指针。 对于双向循环链表，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。 特别地，我们希望可以就地完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继。还需要返回链表中的第一个节点的指针。
LeetCode 第427题：建立四叉树
给你一个 n n 矩阵 grid ，矩阵由若干 0 和 1 组成。请你用四叉树表示该矩阵 grid 。 四叉树是一种树数据结构，其中每个结点都有四个子结点。此外，每个结点都有两个属性： - val：储存叶子结点所代表的区域的值。1 对应 True，0 对应 False； - isLeaf：当这个节点是叶子结点时为 True，如果它有 4 个子节点则为 Fal
LeetCode 第428题：序列化和反序列化 N 叉树
序列化是指将一个数据结构转化为位序列的过程，因此可以将其存储在文件中或通过网络传输，同时也可以通过反序列化过程恢复。 设计一个序列化和反序列化 N 叉树的算法。一个 N 叉树是指每个节点都有不超过 N 个子节点的有根树。序列化/反序列化算法的算法实现没有限制。你只需要保证 N 叉树可以被序列化为一个字符串并且该字符串可以被反序列化成原树结构即可。
LeetCode 第429题：N叉树的层序遍历
给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。 树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
LeetCode 第430题：扁平化多级双向链表
你会得到一个双向链表，其中包含的节点有一个下一个指针、一个前一个指针和一个额外的 子指针 。这个子指针可能指向一个单独的双向链表，也包含这些特殊的节点。这些子列表可能有一个或多个自己的子项，以此类推，形成多级数据结构。 给定链表的头节点 head ，将链表 扁平化 ，使所有节点都出现在单级双链表中。让 curr 是一个带有子列表的节点。子列表中的节点应该出现
LeetCode 第289题：生命游戏
根据百度百科，生命游戏，简称为生命，是英国数学家约翰·何顿·康威在1970年发明的细胞自动机。 给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态：1 即为活细胞（live），或 0 即为死细胞（dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律： 1. 如果活细胞周围八个位
LeetCode 第297题：二叉树的序列化与反序列化
序列化是将一个数据结构或者对象转换为一个字符串的过程，以便于存储或传输。同样，反序列化是将字符串转换为原始数据结构或对象的过程。 请设计一个算法来实现二叉树的序列化与反序列化。不限定序列化/反序列化算法执行细节，只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
LeetCode 第304题：二维区域和检索 - 矩阵不可变
给定一个二维矩阵 matrix，以下类型的多个请求： - 计算其子矩形范围内元素的总和，该子矩阵的左上角为 (row1, col1) ，右下角为 (row2, col2) 。 实现 NumMatrix 类： - NumMatrix(int[][] matrix) 给定整数矩阵 matrix 进行初始化 - int sumRegion(int row1, in
LeetCode 第310题：最小高度树
树是一个无向图，其中任何两个顶点只通过一条路径连接。换句话说，一个任何没有简单环路的连通图都是一棵树。 给你一棵包含 n 个节点的树，标记为 0 到 n - 1 。给定数字 n 和一个有 n - 1 条无向边的 edges 列表（每一个边都是一对标签），其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间存在一条无向边。 可选择树
LeetCode 第319题：灯泡开关
初始时有 n 个灯泡处于关闭状态。第一轮，你将会打开所有灯泡。第二轮，你将会每两个灯泡关闭一个。 第三轮，你每三个灯泡就切换一个灯泡的开关（即，打开变关闭，关闭变打开）。第 i 轮，你每 i 个灯泡就切换一个灯泡的开关。直到第 n 轮，你只需要切换最后一个灯泡的开关。 找出并返回 n 轮后有多少个亮着的灯泡。
LeetCode 第328题：奇偶链表
给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。 第一个节点的索引被认为是奇数，第二个节点的索引为偶数，以此类推。 请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。 你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。
LeetCode 第329题：矩阵中的最长递增路径
给定一个 m x n 整数矩阵 matrix ，找出其中最长递增路径的长度。 对于每个单元格，你可以往上、下、左、右四个方向移动。你不能在对角线方向上移动或移动到边界外（即不允许环绕）。
LeetCode 第331题：验证二叉树的前序序列化
序列化二叉树的一种方法是使用前序遍历。当我们遇到一个非空节点时，我们可以记录下这个节点的值。如果它是一个空节点，我们可以使用一个标记值记录，例如 #。 例如，上面的二叉树可以被序列化为字符串 "9,3,4,#,#,1,#,#,2,#,6,#,#"，其中 # 代表一个空节点。 给定一串以逗号分隔的序列，验证它是否是正确的二叉树的前序序列化。编写一个在不重构树的
LeetCode 第332题：重新安排行程
给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。 所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。 - 例如，行程 ["JFK", "LGA"] 与
LeetCode 第335题：路径交叉
给你一个整数数组 distance 。 从 X-Y 平面上的点 (0,0) 开始，先向北移动 distance[0] 个单位，然后向西移动 distance[1] 个单位，向南移动 distance[2] 个单位，向东移动 distance[3] 个单位，持续移动。也就是说，每次移动后你的方位会发生逆时针变化。 判断你所经过的路径是否相交。如果相交，返回 t
LeetCode 第337题：打家劫舍 III
小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。 除了 root 之外，每栋房子有且只有一个"父"房子与之相连。一番侦察之后，聪明的小偷意识到"这个地方的所有房屋的排列类似于一棵二叉树"。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。 给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高
LeetCode 第341题：扁平化嵌套列表迭代器
给你一个嵌套的整型列表。请你设计一个迭代器，使其能够遍历这个整型列表中的所有整数。 列表中的每一项或者为一个整数，或者是另一个列表。其中列表的元素也可能是整数或是其他列表。
LeetCode 第348题：设计井字棋
请在 n × n 的棋盘上，实现一个判定井字棋（Tic-Tac-Toe）胜负的神器，判断每一次玩家落子后，是否有胜出的玩家。 在这个井字棋游戏中，会有 2 名玩家，他们将轮流在棋盘上放置自己的棋子。 实现 TicTacToe 类： - TicTacToe(int n) 初始化游戏棋盘，大小为 n x n - int move(int row, int col
LeetCode 第351题：安卓系统手势解锁
我们都知道安卓有个手势解锁的界面，是一个 3 x 3 的点所绘制出来的网格。给你两个整数，分别为 m 和 n，其中 1 ≤ m ≤ n ≤ 9，那么请你统计一下有多少种解锁手势，是至少需要经过 m 个点，但是最多经过不超过 n 个点的。 先来了解下什么是一个有效的安卓解锁手势: 1. 每一个解锁手势必须至少经过 m 个点、最多经过 n 个点。 2. 解锁手势
LeetCode 第353题：贪吃蛇游戏
请你设计一个贪吃蛇游戏，该游戏将会在一个 屏幕尺寸 = 宽度 x 高度 的屏幕上运行。 起初时，蛇在左上角的 (0, 0) 位置，身体长度为 1 个单位。你将会被给出一个 (行, 列) 形式的食物位置序列。 实现 SnakeGame 类： - SnakeGame(int width, int height, int[][] food) 初始化对象，屏幕大小为
LeetCode 第363题：矩形区域不超过K的最大数值和
给你一个 m x n 的矩阵 matrix 和一个整数 k ，找出并返回矩阵内部矩形区域的不超过 k 的最大数值和。 题目数据保证总会存在一个数值和不超过 k 的矩形区域。
LeetCode 第375题：猜数字大小II
我们正在玩一个猜数游戏，游戏规则如下： - 我从 1 到 n 之间选择一个数字。 - 你来猜我选了哪个数字。 - 如果你猜到正确的数字，你就赢了。 - 如果你猜错了，我会告诉你，你猜的数字是大了还是小了，并且你需要支付你猜的数字的金额。 给定一个特定的 n，返回你确保能赢得游戏所需的最少金额。
LeetCode 第382题：链表随机节点
给定一个单链表，随机选择链表的一个节点，并返回相应的节点值。保证每个节点被选中的概率相等。
LeetCode 第388题：文件的最长绝对路径
假设我们以下述方式存储文件： dir subdir1 file1.ext subsubdir1 subdir2 subsubdir2 file2.ext 文件系统由文件和目录组成，每个文件和目录都有一个唯一的名称。文件系统以字符串形式表示，其中： - 每个文件或目录的名称由字母、数字和/或空格组成 - 每个文件或目录的名称长度不超过20个字符 - 每个文件或
LeetCode第391题：完美矩形
LeetCode第391题：完美矩形
LeetCode第396题：旋转函数
给定一个长度为 n 的整数数组 nums。 假设 arrk 是数组 nums 顺时针旋转 k 个位置后的数组，我们定义 nums 的 旋转函数 F 为： F(k) = 0 arrk[0] + 1 arrk[1] + ... + (n - 1) arrk[n - 1] 返回 F(0), F(1), ..., F(n-1) 中的最大值。 生成的测试用例让答案符合
LeetCode第397题：整数替换
给定一个正整数 n，你可以做如下操作： 1. 如果 n 是偶数，则用 n / 2 替换 n。 2. 如果 n 是奇数，则可以用 n + 1 或 n - 1 替换 n。 返回 n 变为 1 所需的 最小替换次数。 示例 1： 输入：n = 8 输出：3 解释：8 -> 4 -> 2 -> 1 示例 2： 输入：n = 7 输出：4 解释：7 -> 8 -> 4
LeetCode第398题：随机数索引
给你一个可能含有 重复元素 的整数数组 nums，请你随机输出给定的目标数字 target 的索引。你可以假设给定的数字一定存在于数组中。 实现 Solution 类： - Solution(int[] nums) 用数组 nums 初始化对象。 - int pick(int target) 从 nums 中选出一个满足 nums[i] == target
LeetCode第399题：除法求值
给你一个变量对数组 equations 和一个实数值数组 values 作为已知条件，其中 equations[i] = [Ai, Bi] 和 values[i] 共同表示等式 Ai / Bi = values[i] 。每个 Ai 或 Bi 是一个表示单个变量的字符串。 另有一些以数组 queries 表示的问题，其中 queries[j] = [Cj, D
LeetCode第400题：第N位数字
给你一个整数 n，请你在无限的整数序列 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...] 中找出并返回第 n 位上的数字。 示例 1： 输入：n = 3 输出：3 示例 2： 输入：n = 11 输出：0 解释：第 11 位数字在序列 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... 里是 0 ，它
LeetCode 第401题：二进制手表
二进制手表顶部有 4 个 LED 代表 小时（0-11），底部的 6 个 LED 代表 分钟（0-59）。每个 LED 代表一个 0 或 1，最低位在右侧。 例如，下面的二进制手表读取 "4:51"。 二进制手表 给你一个整数 turnedOn，表示当前亮着的 LED 的数量，返回二进制手表可以表示的所有可能时间。你可以按任意顺序返回答案。 小时不会以零开头
LeetCode 第402题：移掉K位数字
给你一个以字符串表示的非负整数 num 和一个整数 k ，移除这个数中的 k 位数字，使得剩下的数字最小。请你以字符串形式返回这个最小的数字。
LeetCode 第404题：左叶子之和
给定二叉树的根节点 root，返回所有左叶子之和。
LeetCode 第405题：数字转换为十六进制数
给定一个整数，编写一个算法将这个数转换为十六进制数。对于负整数，我们通常使用补码运算方法。 注意: 1. 十六进制中所有字母(a-f)都必须是小写。 2. 十六进制字符串中不能包含多余的前导零。如果要转化的数为0，那么以单个字符'0'来表示；对于其他情况，十六进制字符串中的第一个字符将不会是0字符。 3. 给定的数确保在32位有符号整数范围内。 4. 不能使
LeetCode第406题：根据身高重建队列
假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。 请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [
LeetCode第407题：接雨水 II
给你一个 m x n 的矩阵，其中的值均为非负整数，代表二维高度图每个单元的高度，请计算图中形状最多能接多少体积的雨水。
LeetCode第408题：有效单词缩写
给一个 非空 字符串 s 和一个缩写 abbr ，请根据这个缩写的规则判断它是否可以是这个字符串的缩写。 字符串的缩写规则如下： 1. 字符串中的每个字母都可以用它的出现次数来替代 2. 缩写必须以字母开头和结尾
LeetCode第409题：最长回文串
给定一个包含大写字母和小写字母的字符串 s ，返回 通过这些字母构造成的 最长的回文串 。 在构造过程中，请注意区分大小写。比如 "Aa" 不能当做一个回文字符串。
LeetCode第410题：分割数组的最大值
给定一个非负整数数组 nums 和一个整数 k ，你需要将这个数组分成 k 个非空的连续子数组。 设计一个算法使得这 k 个子数组各自和的最大值最小。
LeetCode第411题：最短独占单词缩写
LeetCode第411题：最短独占单词缩写
LeetCode 第412题：Fizz Buzz
给你一个整数 n ，返回一个字符串数组 answer（下标从 1 开始），其中： - answer[i] == "FizzBuzz" 如果 i 同时是 3 和 5 的倍数。 - answer[i] == "Fizz" 如果 i 是 3 的倍数。 - answer[i] == "Buzz" 如果 i 是 5 的倍数。 - answer[i] == i （以字符
LeetCode 第413题：等差数列划分
如果一个数列 至少有三个元素 ，并且任意两个相邻元素之差相同，则称该数列为等差数列。 - 例如，[1,3,5,7,9]、[7,7,7,7] 和 [3,-1,-5,-9] 都是等差数列。 给你一个整数数组 nums ，返回数组 nums 中所有为等差数组的 子数组 个数。 子数组 是数组中的一个连续序列。
LeetCode 第414题：第三大的数
给你一个非空数组，返回此数组中 第三大的数 。如果不存在，则返回数组中最大的数。
LeetCode 第415题：字符串相加
给定两个字符串形式的非负整数 num1 和 num2 ，计算它们的和并同样以字符串形式返回。 你不能使用任何內建的用于处理大整数的库（比如 BigInteger），也不能直接将输入的字符串转换为整数形式。
LeetCode 第416题：分割等和子集
给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
LeetCode 第417题：太平洋大西洋水流问题
有一个 m × n 的矩形岛屿，与 太平洋 和 大西洋 相邻。 太平洋 处于大陆的左边界和上边界，而 大西洋 处于大陆的右边界和下边界。 这个岛被分割成一个由若干方形单元格组成的网格。给定一个 m x n 的整数矩阵 heights ， heights[r][c] 表示坐标 (r, c) 上单元格 高于海平面的高度 。 岛上雨水较多，如果相邻单元格的高度 小
LeetCode 第418题：屏幕可显示句子的数量
给你一个 rows x cols 的屏幕和一个用字符串数组表示的句子 sentence ，其中 sentence[i] 表示单个单词。 你想要在屏幕上显示这个句子。 单词应该逐行显示，每行可以容纳若干单词，单词之间用一个空格分隔。每个单词只能显示一次。 每行开头和结尾都不能有空格。 你需要找出能够容纳整个句子的最大重复次数。
LeetCode 第419题：甲板上的战舰
给你一个大小为 m x n 的矩阵 board 表示甲板，其中，每个单元格可以是一艘战舰 'X' 或者是一个空位 '.' 。 返回在甲板 board 上放置的 战舰 的数量。 战舰 只能水平或者垂直放置在 board 上。换句话说，战舰只能由 1 x k 的连续单元格组成，其中 k 可以是 1 或者一个大于 1 的整数。这些单元格必须在矩阵中连续相邻。
LeetCode 第420题：强密码检验器
如果一个密码满足下述所有条件，则认为这个密码是强密码： - 由至少 6 个，至多 20 个字符组成。 - 至少包含 一个小写 字母，一个大写 字母，和 一个数字 。 - 同一字符 不能 连续出现三次 (比如 "...aaa..." 是不允许的, 但是 "...aa...a..." 如果满足其他条件也可以视作是强密码)。 给你一个字符串 password ，返
LeetCode 第354题：俄罗斯套娃信封问题
给你一个二维整数数组 envelopes ，其中 envelopes[i] = [wi, hi] ，表示第 i 个信封的宽度和高度。 当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。 请计算 最多能有多少个 信封能组成一组"俄罗斯套娃"信封（即可以把一个信封放到另一个信封里面）。 注意：不允许旋转信封。
LeetCode 第355题：设计推特
设计一个简化版的推特(Twitter)，可以让用户实现发送推文，关注/取消关注其他用户，能够看见关注人（包括自己）的最近十条推文。你的设计需要支持以下的几个功能： 1. postTweet(userId, tweetId): 创建一条新的推文 2. getNewsFeed(userId): 检索最近的十条推文。每个推文都必须是由此用户关注的人或者是用户自己发
LeetCode 第356题：直线镜像
给定平面上的n个点，判断这些点是否关于某条直线对称。
LeetCode 第357题：计算各个位数不同的数字个数
给定一个非负整数 n，计算各位数字都不同的数字 x 的个数，其中 0 ≤ x < 10^n。
LeetCode 第358题：K距离间隔重排字符串
给定一个字符串 s 和一个整数 k，你需要重新排列字符串，使得相同的字符之间至少间隔 k 个字符。如果无法重新排列，则返回空字符串。
LeetCode 第359题：日志速率限制器
请你设计一个日志系统，可以流式接收日志及其时间戳。 该日志系统支持以下操作： 1. 接收日志：接收一条日志消息及其时间戳 2. 判断是否应该打印：如果该条日志在给定的时间窗口内（例如10秒）没有被打印过，则返回true，否则返回false
LeetCode 第360题：有序转化数组
给你一个已经排好序的整数数组 nums 和整数 a、b、c。对于数组中的每一个数 x，计算函数值 f(x) = ax^2 + bx + c，请将函数值也按照升序排序。
LeetCode 第361题：轰炸敌人
给你一个二维的网格图，其中： - 'W' 表示一堵墙 - 'E' 表示一个敌人 - '0'（数字0）表示一个空位 请你计算一个炸弹最多能炸死多少个敌人。炸弹只能放在空位上，并且炸弹的爆炸范围是： - 向上、下、左、右四个方向 - 直到碰到墙或者网格边界为止 - 不能穿过墙
LeetCode 第362题：敲击计数器
设计一个敲击计数器，使它可以统计在过去5分钟内被敲击的次数。 你的系统应该接受一个时间戳参数（以秒为单位），并且你可以假设对系统的调用是按时间顺序进行的（即时间戳是单调递增的）。你可能在同一个时间戳内收到多个敲击请求。 实现 HitCounter 类： - HitCounter() 初始化敲击计数器系统。 - void hit(int timestamp)
LeetCode 第371题：两整数之和
不使用运算符 + 和 -，计算两整数 a、b 之和。
LeetCode 第372题：超级次方
你的任务是计算 a^b mod 1337，其中 a 是一个正整数，b 是一个非常大的正整数且会以数组形式给出。
LeetCode 第373题：查找和最小的K对数字
给定两个以升序排列的整数数组 nums1 和 nums2，以及一个整数 k。 定义一对值 (u,v)，其中第一个元素来自 nums1，第二个元素来自 nums2。 请找到和最小的 k 个数对 (u1,v1), (u2,v2) ... (uk,vk)。
LeetCode 第374题：猜数字大小
猜数字游戏的规则如下： - 每轮游戏，我都会从 1 到 n 随机选择一个数字。请你猜选出的是哪个数字。 - 如果你猜错了，我会告诉你，你猜测的数字比我选出的数字是大了还是小了。 你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果，返回值一共有 3 种可能的情况（-1，1 或 0）： - -1：我选出的数字比你猜的数字小
LeetCode 第376题：摆动序列
如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。 例如，[1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反，[1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是
LeetCode 第377题：组合总和IV
给你一个由不同整数组成的数组nums，和一个目标整数target。请你从nums中找出并返回总和为target的元素组合的个数。 题目数据保证答案符合32位整数范围。
LeetCode 第378题：有序矩阵中第K小的元素
给你一个n x n矩阵matrix，其中每行和每列元素均按升序排序，找到矩阵中第k小的元素。 请注意，它是排序后的第k小元素，而不是第k个不同的元素。
LeetCode 第379题：电话目录管理系统
设计一个电话目录管理系统，让它支持以下操作： 1. get: 分配给用户一个未被使用的电话号码，获取失败请返回 -1 2. check: 检查指定的电话号码是否可用 3. release: 释放掉一个电话号码，使其能够重新被分配
LeetCode 第380题：常数时间插入、删除和获取随机元素
设计一个支持在平均时间复杂度O(1)下，执行以下操作的数据结构： 1. insert(val)：当元素val不存在时，向集合中插入该项。 2. remove(val)：元素val存在时，从集合中移除该项。 3. getRandom：随机返回现有集合中的一项。每个元素应该有相同的概率被返回。
LeetCode 第381题：O(1)时间插入、删除和获取随机元素-允许重复
设计一个支持在平均时间复杂度O(1)下，执行以下操作的数据结构： 1. insert(val)：当元素val不存在时，向集合中插入该项。 2. remove(val)：元素val存在时，从集合中移除该项。 3. getRandom：随机返回现有集合中的一项。每个元素应该有相同的概率被返回。 注意：允许集合中出现重复的元素。
LeetCode 第383题：赎金信
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
LeetCode 第384题：打乱数组
给你一个整数数组 nums ，设计算法来打乱一个没有重复元素的数组。 实现 Solution class: - Solution(int[] nums) 使用整数数组 nums 初始化对象 - int[] reset() 重设数组到它的初始状态并返回 - int[] shuffle() 返回数组随机打乱后的结果
LeetCode 第385题：迷你语法分析器
给定一个用字符串表示的整数的嵌套列表，实现一个解析它的语法分析器。 列表中的每个元素只可能是整数或整数列表。
LeetCode 第386题：字典序排数
给定一个整数 n, 返回从 1 到 n 的字典序排列。
LeetCode 第387题：字符串中的第一个唯一字符
给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
LeetCode 第389题：找不同
给定两个字符串 s 和 t，它们只包含小写字母。 字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。 请找出在 t 中被添加的字母。
LeetCode 第390题：消除游戏
给定一个从1到n的整数列表。首先，从左到右，从第一个数字开始，每隔一个数字删除一个，直到列表末尾。然后，在剩下的数字中，从右到左，从最后一个数字开始，每隔一个数字删除一个，直到列表开头。我们重复这两步，从左到右和从右到左交替进行，直到只剩下一个数字。 找到这个最后剩下的数字。
LeetCode 第392题：判断子序列
给定字符串 s 和 t，判断 s 是否为 t 的子序列。 子序列是指可以通过删除 t 中的某些字符（可以为0个），而不改变剩余字符的相对顺序得到的字符串。
LeetCode 第393题：UTF-8 编码验证
给定一个表示数据的整数数组 data ，返回它是否为有效的 UTF-8 编码。 UTF-8 中的一个字符可能的长度为 1 到 4 字节，遵循以下的规则： - 1 字节：首位为 0 - n 字节：前 n 位为 1，第 n+1 位为 0，后续字节前两位为 10
LeetCode 第394题：字符串解码
给定一个经过编码的字符串，返回它解码后的字符串。 编码规则为: k[encodedstring]，表示其中方括号内部的 encodedstring 正好重复 k 次。k 保证为正整数。
LeetCode 第395题：至少有K个重复字符的最长子串
给定一个字符串 s 和一个整数 k，返回 s 中最长的子字符串的长度，要求该子字符串中的每一字符出现次数都不少于 k。
LeetCode 第291题：单词规律 II
给定一种规律 pattern 和一个字符串 str，判断 str 是否遵循相同的规律。 这里的遵循指完全匹配，例如，pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。 与第290题不同的是，这里的str不需要按空格分割，而是可以任意分割。
LeetCode 第292题：Nim 游戏
你和你的朋友，两个人一起玩 Nim 游戏： - 桌子上有一堆石头。 - 你们轮流进行自己的回合，你作为先手。 - 每一回合，轮到的人可以拿掉 1 - 3 块石头。 - 拿掉最后一块石头的人就是获胜者。 假设你们每一步都是最优解。请编写一个函数，来判断你是否可以在给定石头数量为 n 的情况下赢得游戏。如果可以赢，返回 true；否则，返回 false。
LeetCode 第293题：翻转游戏
你和朋友玩一个叫做"翻转游戏"的游戏，游戏规则如下： - 给定一个只包含字符 '+' 和 '-' 的字符串。 - 你和朋友轮流进行，你作为先手。 - 每次操作，你可以选择两个连续的 '+' 字符，将它们都变成 '-'。 - 无法进行操作的人输掉游戏。 编写一个函数，计算所有可能的下一步操作。每个操作都应该是一个字符串，表示进行一次操作后的状态。
LeetCode 第349题：两个数组的交集
给定两个数组 nums1 和 nums2 ，返回它们的交集。输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。
LeetCode 第350题：两个数组的交集 II
给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。
LeetCode 第352题：将数据流变为多个不相交区间
给你一个由非负整数 a1, a2, ..., an 组成的数据流输入，请你将到目前为止看到的数字总结为不相交的区间列表。 实现 SummaryRanges 类： - SummaryRanges() 使用一个空数据流初始化对象 - void addNum(int val) 向数据流中加入整数 val - int[][] getIntervals() 以不相交区
LeetCode 第240题：搜索二维矩阵 II
编写一个高效的算法来搜索 m × n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性： - 每行的元素从左到右升序排列。 - 每列的元素从上到下升序排列。
LeetCode第241题：为运算表达式设计优先级
LeetCode第241题：为运算表达式设计优先级
LeetCode第242题：有效的字母异位词
LeetCode第242题：有效的字母异位词
LeetCode第243题：最短单词距离
LeetCode第243题：最短单词距离
LeetCode第244题：最短单词距离II
LeetCode第244题：最短单词距离II
LeetCode第245题：最短单词距离III
LeetCode第245题：最短单词距离III
LeetCode第246题：中心对称数
LeetCode第246题：中心对称数
LeetCode第247题：中心对称数II
LeetCode第247题：中心对称数II
LeetCode第248题：特殊的回文数III
LeetCode第248题：特殊的回文数III
LeetCode第249题：移位字符串分组
LeetCode第249题：移位字符串分组
LeetCode第250题：统计同值子树
LeetCode第250题：统计同值子树
LeetCode第251题：展平二维向量
设计并实现一个迭代器，用于展平二维向量。该迭代器需要支持 next() 和 hasNext() 两个操作。
LeetCode第252题：会议室
给定一个会议时间安排的数组 intervals ，每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ，请你判断一个人是否能够参加这里面的全部会议。
LeetCode第253题：会议室II
给你一个会议时间安排的数组 intervals ，每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ，为避免会议冲突，同时要考虑充分利用会议室资源，请你计算至少需要多少间会议室，才能满足这些会议安排。
LeetCode第254题：因子的组合
整数可以被看作是其因子的乘积。 例如： - 8 = 2 × 4 - 8 = 2 × 2 × 2 - 12 = 2 × 6 - 12 = 2 × 2 × 3 - 12 = 3 × 4 请实现一个函数，该函数接收一个整数 n 并返回该整数所有的因子组合。 注意： 1. 你可以假设 n 为正整数。 2. 因子必须大于 1 且小于 n。 3. 结果中不必包含 n 本
LeetCode第255题：验证前序遍历序列二叉搜索树
给定一个整数数组，你需要验证它是否是一个二叉搜索树的前序遍历序列。 二叉搜索树的定义如下： - 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值； - 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值； - 任意节点的左、右子树也分别为二叉搜索树。
LeetCode第256题：粉刷房子
假如有一排房子，共 n 个，每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。 当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 n x 3 的矩阵来表示的。 例如，costs[0][0] 表示第 0 号房子粉刷成红色的成本
LeetCode第257题：二叉树的所有路径
给你一个二叉树的根节点 root ，按任意顺序，返回所有从根节点到叶子节点的路径。 叶子节点是指没有子节点的节点。
LeetCode第258题：各位相加
给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。返回这个结果。
LeetCode第259题：较小的三数之和
给定一个长度为 n 的整数数组 nums 和一个目标值 target，寻找能够使条件 nums[i] + nums[j] + nums[k] < target 成立的三元组 i, j, k 个数（0 <= i < j < k < n）。
LeetCode 第260题：只出现一次的数字 III
给你一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。找出只出现一次的那两个元素。你可以按 任意顺序 返回答案。 你必须设计并实现线性时间复杂度的算法且仅使用常量额外空间来解决此问题。
LeetCode 第261题：以图判树
给定从 0 到 n-1 标号的 n 个结点，和一个无向边列表（每条边以结点对来表示），请编写一个函数用来判断这些边是否能够形成一个合法有效的树结构。
LeetCode 第262题：行程和用户
Trips 表中存所有出租车的行程信息。每段行程有唯一键 Id，ClientId 和 DriverId 是 Users 表中 UsersId 的外键。Status 是枚举类型，枚举成员为 ('completed', 'cancelledbydriver', 'cancelledbyclient')。 +----+-----------+-----------
LeetCode 第263题：丑数
编写一个程序判断给定的数是否为丑数。 丑数就是只包含质因数 2, 3, 5 的正整数。
LeetCode 第264题：丑数 II
编写一个程序，找出第 n 个丑数。 丑数就是只包含质因数 2, 3, 5 的正整数。
LeetCode 第265题：粉刷房子 II
假如有一排房子，共 n 个，每个房子可以被粉刷成 k 种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。 当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 n x k 的矩阵来表示的。 例如，costs[0][0] 表示第 0 号房子粉刷成 0 号颜色的成本花费；c
LeetCode 第266题：回文排列
给定一个字符串，判断该字符串中是否可以通过重新排列组合，形成一个回文字符串。 回文字符串是指正着读和反着读都一样的字符串。
LeetCode 第267题：回文排列 II
给定一个字符串 s，返回其通过重新排列组合后所有可能的回文字符串，并去除重复的组合。 如不能形成任何回文排列时，则返回一个空列表。
LeetCode 第268题：丢失的数字
给定一个包含 [0, n] 中 n 个数的数组 nums，找出 [0, n] 这个范围内没有出现在数组中的那个数。
LeetCode 第269题：火星词典
现有一种使用英语字母的外星文字，这种外星文字也使用英语字母，但可能顺序不同。字母表的顺序（order）是这种外星文字中字母的顺序。 给定一组用外星文字书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星文字中按字典序排列时，返回 true；否则，返回 false。
LeetCode 第270题：最接近的二叉搜索树值
给定一个不为空的二叉搜索树和一个目标值 target，请在该二叉搜索树中找到最接近目标值 target 的数值。 注意： - 给定的目标值 target 是一个浮点数 - 题目保证在该二叉搜索树中只会存在一个最接近目标值的数
LeetCode 第271题：字符串编码解码
设计一个算法来编码字符串列表。编码后的字符串将通过网络发送，并在另一端解码回原始字符串列表。 机器1（发送方）具有以下功能： string encode(vector strs) { // ... 你的代码 return encodedstring; } 机器2（接收方）具有以下功能： vector decode(string s) { // ... 你的代
LeetCode 第272题：最接近的二叉搜索树值 II
给定一个非空二叉搜索树和一个目标值 target，请在该二叉搜索树中找到最接近目标值 target 的 k 个值。 注意： - 给定的目标值 target 是一个浮点数 - 你可以默认 k 值永远是有效的，即 k ≤ 总结点数 - 题目保证该二叉搜索树中只会存在一种 k 个值集合最接近目标值
LeetCode 第273题：整数转换英文表示
将非负整数 num 转换为其对应的英文表示。
LeetCode 第274题：H指数
给你一个整数数组 citations，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数。计算并返回该研究者的 h 指数。 根据维基百科上 h 指数 的定义：h 代表"高引用次数"，一名科研人员的 h 指数是指他（她）的 （n 篇论文中）总共有 h 篇论文分别被引用了至少 h 次。且其余的 n - h 篇论文每篇被引用次数 不超过 h 次
LeetCode 第275题：H指数 II
给你一个整数数组 citations，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数，citations 已经按照 升序排列。计算并返回该研究者的 h 指数。 h 指数的定义：h 代表"高引用次数"，一名科研人员的 h 指数是指他（她）的 （n 篇论文中）总共有 h 篇论文分别被引用了至少 h 次。且其余的 n - h 篇论文每篇被引
LeetCode 第276题：栅栏涂色
有 k 种颜色的涂料和一个包含 n 个栅栏柱的栅栏，每个栅栏柱必须涂上颜色。 相邻的栅栏柱 最多连续两个 颜色相同。 给你两个整数 k 和 n ，返回所有有效涂色的方案数。答案可能很大，请返回对 10^9 + 7 取模的结果。
LeetCode 第277题：寻找名人
假设你是一个专业的狗仔，参加了一个 n 人派对，其中每个人被从 0 到 n - 1 标号。在这个派对中，只有一个 "名人"。所谓 "名人" 的定义是： 1. 所有其他人都认识他/她 2. 他/她不认识任何其他人 现在你想要确认这个 "名人" 是谁，或者确定这个 "名人" 不存在。而你只能问诸如 "A 你好呀，请问你认识 B 吗？" 的问题。你需要尽可能少的问
LeetCode 第278题：第一个错误的版本
你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。 假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。 你可以通过调用 bool IsBadVersion(version) 接口来判断版本号
LeetCode 第279题：完全平方数
给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。 完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。
LeetCode 第280题：摆动排序
给你一个无序的数组 nums，请你将数组中的数字按照以下规则重新排序： 1. 如果 i 是奇数，那么 nums[i] >= nums[i - 1] 2. 如果 i 是偶数，那么 nums[i] = nums[2] = nums[4] <= ... 请你原地修改数组，使其满足上述要求。
LeetCode 第281题：锯齿迭代器
给出两个一维向量，请你实现一个迭代器来交替返回它们中间的元素。 实现 ZigzagIterator 类： - ZigzagIterator(vector& v1, vector& v2) 使用两个向量v1和v2初始化迭代器 - boolean hasNext() 如果还有元素返回 true ；否则返回 false 。 - int next() 返回下一个元素
LeetCode 第282题：给表达式添加运算符
给定一个仅包含数字 0-9 的字符串 num 和一个目标值整数 target ，在 num 的数字之间添加 二元 运算符（不是一元）+、- 或 ，返回所有能够得到目标值的表达式。 注意： - 返回的表达式中，操作符 +、- 和 的优先级遵循正常的数学运算规则。 - 不能用括号改变运算符的优先级。 - 不能有前导零，但 0 本身是允许的。
LeetCode 第283题：移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。 请注意： 1. 必须在原数组上操作，不能拷贝额外的数组。 2. 尽量减少操作次数。
LeetCode 第284题：顶端迭代器
给定一个迭代器类的接口，接口包含两个方法： next() 和 hasNext()。设计并实现一个支持 peek() 操作的顶端迭代器 -- 其本质就是把原本应由 next() 方法返回的元素 peek() 出来。 实现 PeekingIterator 类： - PeekingIterator(Iterator iter) 使用指定的整数迭代器 iter 初始
LeetCode 第285题：二叉搜索树中的顺序后继
给定一棵二叉搜索树和其中的一个节点 p ，找到该节点在树中的中序后继。如果节点没有中序后继，请返回 null 。 节点 p 的后继是值比 p.val 大的节点中值最小的节点。
LeetCode 第286题：墙与门
你被给定一个 m × n 的二维网格，网格中有以下三种可能的初始化值： - -1 表示墙或障碍物 - 0 表示一扇门 - INF 表示一个空的房间。我们使用值 2^31 - 1 = 2147483647 来表示 INF 你要给每个空房间填上到最近门的距离。如果无法到达门，则填 INF。
LeetCode 第287题：寻找重复数
给定一个包含 n + 1 个整数的数组 nums，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。假设只有一个重复的整数，找出这个重复的数。
LeetCode 第288题：单词的唯一缩写
一个单词的缩写需要遵循以下格式：首字母 + 中间字母数量 + 尾字母。例如： - "internationalization" 的缩写是 "i18n" - "localization" 的缩写是 "l10n" 实现一个 ValidWordAbbr 类： - ValidWordAbbr(String[] dictionary) 初始化对象 - boolean
LeetCode 第290题：单词规律
给定一种规律 pattern 和一个字符串 str，判断 str 是否遵循相同的规律。 这里的遵循指完全匹配，例如，pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。
LeetCode 第294题：翻转游戏 II
你和朋友玩一个叫做"翻转游戏"的游戏： - 给定一个只包含字符 '+' 和 '-' 的字符串。 - 你和朋友轮流进行，你作为先手。 - 每次操作，你可以选择两个连续的 '+' 字符，将它们都变成 '-'。 - 无法进行操作的人输掉游戏。 请你写一个函数来判断是否存在必胜策略。如果先手玩家必胜，返回 true；否则，返回 false。
LeetCode 第295题：数据流的中位数
中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。 设计一个支持以下两种操作的数据结构： - void addNum(int num) - 从数据流中添加一个整数到数据结构中。 - double findMedian() - 返回目前所有元素的中位数。
LeetCode 第296题：最佳的碰头地点
给定一个 m x n 的二进制网格 grid，其中 1 表示房屋，0 表示空地。找到一个空地，使得所有房屋到该点的曼哈顿距离之和最小。 曼哈顿距离定义为：|x1 - x2| + |y1 - y2|，其中 (x1, y1) 和 (x2, y2) 是两个点的坐标。 如果没有房屋，返回 0。
LeetCode 第298题：二叉树最长连续序列
给你一棵指定的二叉树的根节点 root ，请你计算其中最长连续序列路径的长度。 最长连续序列路径是依次递增的路径。该路径，可以是从某个初始节点到树中任意节点，通过「父 - 子」关系连接而产生的任意路径。且必须从父节点到子节点，反过来是不可以的。
LeetCode 第299题：猜数字游戏
你在和朋友一起玩 猜数字（Bulls and Cows）游戏，该游戏规则如下： 写出一个秘密数字，并请朋友猜这个数字是多少。朋友每猜测一次，你就要给他一个包含下述信息的提示： - 猜中了多少个"公牛"（Bulls）：位置和数字都对的数字个数。 - 有多少个"奶牛"（Cows）：数字对但位置不对的数字个数。 给你一个秘密数字 secret 和朋友猜测的数字 g
LeetCode 第300题：最长递增子序列
给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。 子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。
LeetCode 第301题：删除无效括号
给你一个由若干括号和字母组成的字符串 s ，删除最小数量的无效括号，使得输入的字符串有效。 返回所有可能的结果。答案可以按 任意顺序 返回。 有效字符串需满足： - 左括号必须用相同数量的右括号闭合。 - 左括号必须在对应的右括号之前。 - 每个右括号都要有一个对应的左括号。
LeetCode 第302题：包含全部黑色像素的最小矩形
给你一个图像数组 image 表示一个二维图像，图像中的每个像素要么是 0（表示白色），要么是 1（表示黑色）。 给你两个整数 x 和 y 表示一个黑色像素的位置。请你找出包含全部黑色像素的最小矩形的面积。 图像是一个二维矩阵，其中 0 表示白色像素，1 表示黑色像素。给定的黑色像素位置 (x, y) 一定是黑色像素。
LeetCode 第303题：区域和检索 - 数组不可变
给定一个整数数组 nums，处理以下类型的多个查询: 1. 计算索引 left 和 right （包含 left 和 right）之间的 nums 元素的 和 ，其中 left <= right 实现 NumArray 类： - NumArray(int[] nums) 使用数组 nums 初始化对象 - int sumRange(int i, int j)
LeetCode 第305题：岛屿数量 II
给你一个大小为 m x n 的二维网格 grid 和一个数组 positions ，其中 positions[i] = [ri, ci] 表示第 i 次操作将单元格 (ri, ci) 的状态更改为 1 （陆地）。一开始，grid 中的所有单元格都是 0 （水）。 返回一个数组 answer ，其中 answer[i] 是将单元格 (ri, ci) 的状态更改
LeetCode 第306题：累加数
累加数是一个字符串，组成它的数字可以形成累加序列。 一个有效的累加序列必须至少包含 3 个数。除了最开始的两个数以外，序列中的每个后续数字必须是它之前两个数字之和。 给你一个只包含数字 '0'-'9' 的字符串，编写一个算法来判断给定输入是否是累加数。如果是，返回 true ；否则，返回 false 。 说明：累加序列里的数，除数字 0 之外，不会以 0 开
LeetCode 第308题：二维区域和检索-可变
给你一个二维矩阵 matrix ，你需要实现以下功能： 1. 更新某个单元格的值 2. 计算子矩阵元素的总和 实现 NumMatrix 类： - NumMatrix(int[][] matrix) 用整数矩阵 matrix 初始化对象 - void update(int row, int col, int val) 更新 matrix[row][col] 的
LeetCode 第309题：最佳买卖股票时机含冷冻期
给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格。 设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）: - 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。 - 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
LeetCode 第311题：稀疏矩阵的乘法
给定两个 稀疏矩阵 A 和 B，请你返回 AB 的结果。你可以默认 A 的列数等于 B 的行数。 请仔细考虑你的实现方案，矩阵 A 和 B 可能非常大，而且稀疏（大部分元素为 0）。
LeetCode 第312题：戳气球
有 n 个气球，编号为0 到 n - 1，每个气球上都标有一个数字，这些数字存在数组 nums 中。 现在要求你戳破所有的气球。戳破第 i 个气球，你可以获得 nums[i-1] nums[i] nums[i+1] 枚硬币。这里的 i-1 和 i+1 代表和 i 相邻的两个气球的序号。如果 i-1 或 i+1 超出了数组的边界，那么就当它是一个数字为 1 的
LeetCode 第313题：超级丑数
超级丑数 是一个正整数，并满足其所有质因数都出现在质数数组 primes 中。 给你一个整数 n 和一个整数数组 primes ，返回第 n 个 超级丑数 。 题目数据保证第 n 个 超级丑数 在 32-bit 带符号整数范围内。
LeetCode 第314题：二叉树的垂直遍历
给你一个二叉树的根节点，请你返回其节点值的垂直遍历顺序（即逐列遍历）。 对位于 (row, col) 的每个结点而言，其左右子结点分别位于 (row + 1, col - 1) 和 (row + 1, col + 1) 。树的根结点位于 (0, 0) 。 节点的垂直坐标用列序号表示，每一列中的所有节点都按照行坐标的顺序（即从上到下）来定位。如果同行同列上有多
LeetCode 第315题：计算右侧小于当前元素的个数
给你一个整数数组 nums，按要求返回一个新数组 counts。数组 counts 有该性质：counts[i] 的值是 nums[i] 右侧小于 nums[i] 的元素的数量。
LeetCode 第316题：去除重复字母
给你一个字符串 s ，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证 返回结果的字典序最小（要求不能打乱其他字符的相对位置）。
LeetCode 第317题：离建筑物最近的距离
你是个房地产开发商，想要选择一片空地 建一栋大楼。你想把这栋大楼够造在一个距离周边设施都比较方便的地方，通过调研，你希望从它出发能到达所有的建筑物，并且该大楼到每个建筑物的距离之和最小。 给你一个由 0、1 和 2 组成的二维网格，其中： - 0 代表你可以自由通过和选择建造的空地 - 1 代表你无法通过的建筑物 - 2 代表你无法通过的障碍物
LeetCode 第318题：最大单词长度乘积
给你一个字符串数组 words ，找出并返回 length(words[i]) length(words[j]) 的最大值，并且这两个单词不含有公共字母。如果不存在这样的两个单词，返回 0 。
LeetCode 第320题：列举单词的全部缩写
请你写出一个能够举单词全部缩写的函数。 注意：输出的顺序并不重要。 缩写规则： 1. 起始字母和结尾字母不能被省略 2. 缩写中间部分可以用数字表示省略的字母数量 3. 如果有多种缩写方式，你需要列举所有可能的缩写
LeetCode 第321题：拼接最大数
给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。 求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。
LeetCode 第322题：零钱兑换
给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。 计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。 你可以认为每种硬币的数量是无限的。
LeetCode 第323题：无向图中连通分量的数目
给定编号从 0 到 n-1 的 n 个节点和一个无向边列表（每条边都是一对节点），请编写一个函数来计算无向图中连通分量的数目。
LeetCode 第324题：摆动排序 II
给你一个整数数组 nums，将它重新排列成 nums[0] nums[2] < nums[3]... 的顺序。 你可以假设所有输入数组都可以得到满足题目要求的结果。
LeetCode 第325题：和等于k的最长子数组长度
给定一个数组 nums 和一个目标值 k，找到和等于 k 的最长连续子数组的长度。如果不存在任意一个符合要求的子数组，则返回 0。
LeetCode 第326题：3的幂
给定一个整数 n，判断它是否是 3 的幂次方。如果是，返回 true ；否则，返回 false 。 整数 n 是 3 的幂次方需满足：存在整数 x 使得 n == 3^x
LeetCode 第327题：区间和的个数
给你一个整数数组 nums 以及两个整数 lower 和 upper 。求数组中，值位于范围 [lower, upper] （包含 lower 和 upper）之内的区间和的个数。 区间和 S(i, j) 表示在 nums 中，位置从 i 到 j 的元素之和，包含 i 和 j (i ≤ j)。
LeetCode 第330题：按要求补齐数组
给定一个已排序的正整数数组 nums，和一个正整数 n。从 [1, n] 区间内选取任意个数字补充到 nums 中，使得 [1, n] 区间内的任何数字都可以用 nums 中某几个数字的和来表示。 请输出满足上述要求的最少需要补充的数字个数。
LeetCode 第333题：最大BST子树
给定一个二叉树，找到其中最大的二叉搜索树（BST）子树，并返回该子树的大小。其中，最大指的是子树节点数最多的。 二叉搜索树（BST）的定义： - 节点的左子树只包含小于当前节点的数。 - 节点的右子树只包含大于当前节点的数。 - 所有左子树和右子树自身必须也是二叉搜索树。
LeetCode 第334题：递增的三元子序列
给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。 如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。
LeetCode 第336题：回文对
给定一组 互不相同 的单词， 找出所有 不同 的索引对 (i, j)，使得列表中的两个单词， words[i] + words[j] ，可拼接成回文串。
LeetCode 第338题：比特位计数
给你一个整数 n ，对于 0 <= i <= n 中的每个 i ，计算其二进制表示中 1 的个数 ，返回一个长度为 n + 1 的数组 ans 作为答案。
LeetCode 第339题：嵌套列表权重和
给定一个嵌套的整数列表 nestedList 。每个元素要么是一个整数，要么是一个列表；该列表的元素也可能是整数或者是其他列表。 整数的 深度 是其在列表内部的嵌套层数。例如，嵌套列表 [1,[2,2],[[3],2],1] 中每个整数的值与其对应的深度为： 1 -> 1 2 -> 2 2 -> 2 3 -> 3 2 -> 3 1 -> 1 请返回该嵌套列表
LeetCode 第340题：至多包含K个不同字符的最长子串
给定一个字符串 s 和一个整数 k ，请找出至多包含 k 个不同字符的最长子串，并返回该子串的长度。
LeetCode 第342题：4的幂
给定一个整数，写一个函数来判断它是否是 4 的幂次方。如果是，返回 true ；否则，返回 false 。 整数 n 是 4 的幂次方需满足：存在整数 x 使得 n == 4^x
LeetCode 第343题：整数拆分
给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。返回你可以获得的最大乘积。
LeetCode 第344题：反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。 不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
LeetCode 第345题：反转字符串中的元音字母
给你一个字符串 s ，仅反转字符串中的所有元音字母，并返回结果字符串。 元音字母包括 'a'、'e'、'i'、'o'、'u'，且可能以大小写两种形式出现。
LeetCode 第346题：数据流中的移动平均值
给定一个整数数据流和一个窗口大小，根据该滑动窗口的大小，计算其所有整数的移动平均值。 实现 MovingAverage 类： - MovingAverage(int size) 用窗口大小 size 初始化对象 - double next(int val) 计算并返回数据流中最后 size 个值的移动平均值
LeetCode 第347题：前K个高频元素
给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按任意顺序返回答案。
LeetCode 第142题：环形链表 II
给定一个链表的头节点 head，返回链表开始入环的第一个节点。如果链表无环，则返回 null。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递
LeetCode 第171题：Excel表列序号
给你一个字符串 columnTitle，表示 Excel 表格中的列名称。返回 该列名称对应的列序号。 例如： A -> 1 B -> 2 C -> 3 ... Z -> 26 AA -> 27 AB -> 28 ...
LeetCode 第172题：阶乘后的零
给定一个整数 n，返回 n! 结果中尾随零的数量。 提示：n! = n (n - 1) (n - 2) ... 3 2 1
LeetCode 第173题：二叉搜索树迭代器
实现一个二叉搜索树迭代器 BSTIterator 类： - BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。 - boolean hasNext() 如果向指针右侧遍历存
LeetCode 第174题：地下城游戏
一些恶魔抓住了公主（P）并将她关在了地下城的右下角。地下城是由 M x N 个房间组成的二维网格。我们英勇的骑士（K）最初被安置在左上角的房间里，他必须穿过地下城并通过对抗恶魔来拯救公主。 骑士的初始健康点数为一个正整数。如果他的健康点数在某一时刻降至 0 或以下，他会立即死亡。 有些房间由恶魔守卫，因此骑士在进入这些房间时会失去健康点数（若房间里的值为负整
LeetCode 第175题：组合两个表
表: Person +-------------+---------+ | 列名 | 类型 | +-------------+---------+ | PersonId | int | | FirstName | varchar | | LastName | varchar | +-------------+---------+ PersonId 是该表的主
LeetCode 第176题：第二高的薪水
编写一个SQL查询，获取 Employee 表中第二高的薪水（Salary）。 +-------------+------+ | Column Name | Type | +-------------+------+ | id | int | | salary | int | +-------------+------+ id 是这个表的主键。 表的每一行包
LeetCode 第177题：第N高的薪水
编写一个 SQL 查询，获取 Employee 表中第 n 高的薪水（Salary）。 +-------------+------+ | Column Name | Type | +-------------+------+ | id | int | | salary | int | +-------------+------+ id 是这个表的主键。 表的
LeetCode 第178题：分数排名
表: Scores +-------------+---------+ | Column Name | Type | +-------------+---------+ | id | int | | score | decimal | +-------------+---------+ id 是该表的主键。 该表的每一行都包含了一场比赛的分数。score 是
LeetCode 第179题：最大数
给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。 注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。
LeetCode 第180题：连续出现的数字
表：Logs +-------------+---------+ | Column Name | Type | +-------------+---------+ | id | int | | num | varchar | +-------------+---------+ id 是这个表的主键。 编写一个 SQL 查询，查找所有至少连续出现三次的数字。
LeetCode 第181题：超过经理收入的员工
表：Employee +-------------+---------+ | Column Name | Type | +-------------+---------+ | id | int | | name | varchar | | salary | int | | managerId | int | +-------------+---------+
LeetCode 第182题：查找重复的电子邮箱
表: Person +-------------+---------+ | Column Name | Type | +-------------+---------+ | id | int | | email | varchar | +-------------+---------+ id 是该表的主键列。 该表的每一行包含一个电子邮件。电子邮件将不包含大
LeetCode 第183题：从不订购的客户
表: Customers +-------------+---------+ | Column Name | Type | +-------------+---------+ | id | int | | name | varchar | +-------------+---------+ id 是该表的主键。 该表包含消费者的 id 和名字。 表: Ord
LeetCode 第184题：部门工资最高的员工
表: Employee +--------------+---------+ | 列名 | 类型 | +--------------+---------+ | id | int | | name | varchar | | salary | int | | departmentId | int | +--------------+---------+ id是
LeetCode 第185题：部门工资前三高的所有员工
表: Employee +--------------+---------+ | Column Name | Type | +--------------+---------+ | id | int | | name | varchar | | salary | int | | departmentId | int | +--------------+---
LeetCode 第186题：反转字符串中的单词 II
给你一个字符数组 s，反转该数组中单词的顺序。 单词的定义是：连续的非空格字符，单词的前后用空格字符隔开。单词中可能包含前导或尾随空格。 请你反转单词的顺序，但不要反转单词内字符的顺序。返回反转后的数组。
LeetCode 第187题：重复的DNA序列
DNA序列由一系列核苷酸组成，缩写为 'A', 'C', 'G' 和 'T'。 例如，"ACGAATTCCG" 是一个 DNA序列。 在研究 DNA 时，识别 DNA 中的重复序列非常有用。 给定一个表示 DNA序列 的字符串 s，返回所有在 DNA 分子中出现不止一次的长度为 10 的序列(子字符串)。你可以按任意顺序返回答案。
LeetCode 第188题：买卖股票的最佳时机 IV
给定一个整数数组 prices，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
LeetCode 第189题：旋转数组
给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
LeetCode 第190题：颠倒二进制位
颠倒给定的 32 位无符号整数的二进制位。 提示： - 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。 - 在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 2 中，输入表
LeetCode 第191题：位1的个数
编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为汉明重量）。
LeetCode 第192题：统计词频
写一个 bash 脚本以统计一个文本文件 words.txt 中每个单词出现的频率。 为了简单起见，你可以假设： 1. words.txt 只包含小写字母和空格 ' ' 。 2. 每个单词只由小写字母组成。 3. 单词间由一个或多个空格字符分隔。
LeetCode 第193题：有效电话号码
给定一个包含电话号码列表（一行一个电话号码）的文本文件 file.txt，写一个单行 bash 脚本输出所有有效的电话号码。 你可以假设一个有效的电话号码必须满足以下两种格式： 1. (xxx) xxx-xxxx 2. xxx-xxx-xxxx 其中 x 是一个数字。 你也可以假设每行前后没有多余的空格字符。
LeetCode 第194题：转置文件
给定一个文件 file.txt，转置其内容。 你可以假设每行列数相同，并且每个字段由空格分隔。
LeetCode 第195题：第十行
给定一个文本文件 file.txt，请只打印这个文件中的第十行。
LeetCode 第196题：删除重复的电子邮箱
编写一个 SQL 查询，删除 Person 表中所有重复的电子邮箱，重复的邮箱里只保留 Id 最小 的那个。
LeetCode 第197题：上升的温度
编写一个 SQL 查询，来查找与之前（昨天的）日期相比温度更高的所有日期的 Id。
LeetCode 第198题：打家劫舍
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
LeetCode 第199题：二叉树的右视图
给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
LeetCode 第200题：岛屿数量
给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。
LeetCode 第201题：数字范围按位与
给你两个整数 left 和 right ，表示区间 [left, right] ，返回此区间内所有数字按位与的结果（包含 left 、right 端点）。
LeetCode 第202题：快乐数
编写一个算法来判断一个数 n 是不是快乐数。 「快乐数」定义为： - 对于一个正整数，每次将该数替换为它每个位置上的数字的平方和。 - 然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。 - 如果这个过程结果为 1，那么这个数就是快乐数。
LeetCode 第203题：删除链表元素
给你一个链表的头节点 head 和一个整数 val，请你删除链表中所有满足 Node.val == val 的节点，并返回新的头节点。
LeetCode 第203题：移除链表元素
给你一个链表的头节点 head 和一个整数 val，请你删除链表中所有满足 Node.val == val 的节点，并返回新的头节点。
LeetCode 第204题：计数质数
给定整数 n，返回所有小于非负整数 n 的质数的数量。
LeetCode 第205题：同构字符串
给定两个字符串 s 和 t，判断它们是否是同构的。 如果 s 中的字符可以按某种映射关系替换得到 t，那么这两个字符串是同构的。 每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。
LeetCode 第206题：反转链表
给你单链表的头节点 head，请你反转链表，并返回反转后的链表。
LeetCode 第207题：课程表
你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1。 在选修某些课程之前需要一些先修课程。先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] 表示如果要学习课程 ai 则必须先学习课程 bi。 例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要
LeetCode 第208题：实现 Trie (前缀树)
Trie（发音类似 "try"）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。 请你实现 Trie 类： - Trie() 初始化前缀树对象。 - void insert(String word) 向前缀树中插入字符串 word。 - boolean search(Stri
LeetCode 第209题：长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 target。 找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr]，并返回其长度。如果不存在符合条件的子数组，返回 0。
LeetCode 第210题：课程表 II
现在你总共有 numCourses 门课需要选，记为 0 到 numCourses - 1。给你一个数组 prerequisites，其中 prerequisites[i] = [ai, bi]，表示在选修课程 ai 前必须先选修 bi。 例如，想要学习课程 0，你需要先完成课程 1，我们用一个匹配来表示：[0,1]。 返回你为了学完所有课程所安排的学习顺序
LeetCode 第211题：添加与搜索单词 - 数据结构设计
请你设计一个数据结构，支持 添加新单词 和 查找字符串是否与任何先前添加的字符串匹配 。 实现词典类 WordDictionary： - WordDictionary() 初始化词典对象 - void addWord(word) 将 word 添加到数据结构中，之后可以对它进行匹配 - bool search(word) 如果数据结构中存在字符串与 word
LeetCode 第212题：单词搜索 II
给定一个 m x n 二维字符网格 board 和一个单词（字符串）列表 words，找出所有同时在二维网格和字典中出现的单词。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中"相邻"单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。
LeetCode 第213题：打家劫舍 II
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组 nums，请计算 在不触动警报装置的情况下，今晚能够偷窃到的最高金额。
LeetCode 第214题：最短回文串
给定一个字符串 s，你可以通过在字符串前面添加字符将其转换为回文串。找到并返回可以用这种方式转换的最短回文串。
LeetCode 第215题：数组中的第K个最大元素
给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。 请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。 你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。
LeetCode 第216题：组合总和 III
找出所有相加之和为 n 的 k 个数的组合，且满足下列条件： - 只使用数字1到9 - 每个数字最多使用一次 返回所有可能的有效组合的列表。该列表不能包含相同的组合两次，组合可以以任何顺序返回。
LeetCode 第217题：存在重复元素
给你一个整数数组 nums 。如果任何值在数组中出现至少两次，返回 true ；如果数组中每个元素互不相同，返回 false 。
LeetCode 第218题：天际线问题
城市的天际线是从远处观看该城市中所有建筑物形成的轮廓的外部轮廓。给你所有建筑物的位置和高度，请返回由这些建筑物形成的天际线。 每个建筑物的几何信息由数组 buildings 表示，其中三元组 buildings[i] = [lefti, righti, heighti] 表示： - lefti 是第 i 座建筑物左边缘的 x 坐标。 - righti 是第
LeetCode 第219题：存在重复元素 II
给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。
LeetCode 第220题：存在重复元素 III
给你一个整数数组 nums 和两个整数 k 和 t 。请你判断是否存在 两个不同下标 i 和 j，使得 abs(nums[i] - nums[j]) <= t ，同时又满足 abs(i - j) <= k 。 如果存在则返回 true，不存在返回 false。
LeetCode 第221题：最大正方形
在一个由 '0' 和 '1' 组成的二维矩阵内，找到只包含 '1' 的最大正方形，并返回其面积。
LeetCode 第222题：完全二叉树的节点个数
给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。 完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1 2^h 个节点。
LeetCode 第223题：矩形面积
给你 二维 平面上两个 由直线构成的 矩形，请你计算并返回两个矩形覆盖的总面积。 每个矩形由其 左下 顶点和 右上 顶点坐标表示： - 第一个矩形由其左下顶点 (ax1, ay1) 和右上顶点 (ax2, ay2) 定义。 - 第二个矩形由其左下顶点 (bx1, by1) 和右上顶点 (bx2, by2) 定义。
LeetCode 第224题：基本计算器
给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。 注意: - s 由数字、'+'、'-'、'('、')'、和 ' ' 组成 - s 表示一个有效的表达式
LeetCode 第225题：用队列实现栈
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。 实现 MyStack 类： - void push(int x) 将元素 x 压入栈顶。 - int pop() 移除并返回栈顶元素。 - int top() 返回栈顶元素。 - boolean empty() 如果栈是空的，返回 t
LeetCode 第226题：翻转二叉树
给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
LeetCode 第227题：基本计算器II
给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。 整数除法仅保留整数部分。 注意: - s 由整数和算符 '+'、'-'、''、'/' 以及 ' ' 组成 - s 表示一个有效的表达式 - 表达式中的所有整数都是非负整数，且在范围 [0, 2^31 - 1] 内 - 题目数据保证答案是一个 32-bit 整数
LeetCode 第228题：汇总区间
给定一个无重复元素的有序整数数组 nums 。 返回 恰好覆盖数组中所有数字的最小有序区间范围列表。也就是说，nums 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个范围但不属于 nums 的数字 x 。 列表中的每个区间范围 [a,b] 应该按如下格式输出： - "a->b" ，如果 a != b - "a" ，如果 a == b
LeetCode 第229题：求众数 II
给定一个大小为 n 的整数数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。 进阶：尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。
LeetCode 第230题：二叉搜索树中第K小的元素
给定一个二叉搜索树的根节点 root，和一个整数 k，请你设计一个算法查找其中第 k 个最小元素（从 1 开始计数）。
LeetCode第231题：2的幂
LeetCode第231题：2的幂
LeetCode第232题：用栈实现队列
LeetCode第232题：用栈实现队列
LeetCode第233题：数字1的个数
LeetCode第233题：数字1的个数
LeetCode第234题：回文链表
LeetCode第234题：回文链表
LeetCode第235题：二叉搜索树的最近公共祖先
LeetCode第235题：二叉搜索树的最近公共祖先
LeetCode第236题：二叉树的最近公共祖先
LeetCode第236题：二叉树的最近公共祖先
LeetCode 第237题：删除链表中的节点
有一个单链表的 head，我们想删除它其中的一个节点 node。 给你一个需要删除的节点 node 。你将 无法访问 第一个节点 head。 链表的所有值都是 唯一的，并且保证给定的节点 node 不是链表中的最后一个节点。 删除给定的节点。注意，删除节点并不是指从内存中删除它。这里的意思是： - 给定节点的值不应该存在于链表中。 - 链表中的节点数应该减少
LeetCode第238题：除自身以外数组的乘积
LeetCode第238题：除自身以外数组的乘积
LeetCode 第239题：滑动窗口最大值
给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回滑动窗口中的最大值。
LeetCode 第121题：买卖股票的最佳时机
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
LeetCode 第122题：买卖股票的最佳时机 II
给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。 在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。 返回你能获得的 最大 利润。
LeetCode 第123题：买卖股票的最佳时机 III
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
LeetCode 第124题：二叉树中的最大路径和
路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。 路径和 是路径中各节点值的总和。 给你一个二叉树的根节点 root ，返回其 最大路径和 。
LeetCode 第125题：验证回文串
如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。 字母和数字都属于字母数字字符。 给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。
LeetCode 第126题：单词接龙 II
按字典 wordList 完成从单词 beginWord 到单词 endWord 转化，一个表示此过程的 转换序列 是形式上像 beginWord -> s1 -> s2 -> ... -> sk 这样的单词序列，并满足： - 每对相邻的单词之间仅有单个字母不同。 - 转换过程中的每个单词 si（1 <= i <= k）必须是字典 wordList 中的单词
LeetCode 第127题：单词接龙
字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列 beginWord -> s1 -> s2 -> ... -> sk： - 每一对相邻的单词只差一个字母。 - 对于 1 <= i <= k 时，每个 si 都在 wordList 中。注意， beginWord 不需要在 wordList 中
LeetCode 第128题：最长连续序列
给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。 请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
LeetCode 第129题：求根节点到叶节点数字之和
给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。 每条从根节点到叶节点的路径都代表一个数字： - 例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。 计算从根节点到叶节点生成的 所有数字之和 。 叶节点 是指没有子节点的节点。
LeetCode 第130题：被围绕的区域
给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' 组成，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。 被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方
LeetCode 第131题：分割回文串
给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。 回文串 是正着读和反着读都一样的字符串。
LeetCode 第132题：分割回文串 II
给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文。 返回符合要求的 最少分割次数 。
LeetCode 第133题：克隆图
给你无向 连通 图中一个节点的引用，请你返回该图的 深拷贝（克隆）。 图中的每个节点都包含它的值 val（int） 和其邻居的列表（list[Node]）。 class Node { public int val; public List neighbors; } 测试用例格式： 简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（val =
LeetCode 第134题：加油站
在一条环路上有 n 个加油站，其中第 i 个加油站有汽油 gas[i] 升。 你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。 给定两个整数数组 gas 和 cost ，如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证
LeetCode 第135题：分发糖果
n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。 你需要按照以下要求，给这些孩子分发糖果： - 每个孩子至少分配到 1 个糖果。 - 相邻两个孩子评分更高的孩子会获得更多的糖果。 请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
LeetCode 第136题：只出现一次的数字
给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。
LeetCode 第137题：只出现一次的数字 II
给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。请你找出并返回那个只出现了一次的元素。 你必须设计并实现线性时间复杂度的算法且不使用额外空间来解决此问题。
LeetCode 第138题：复制带随机指针的链表
给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表
LeetCode 第139题：单词拆分
给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。 注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。
LeetCode 第140题：单词拆分 II
给定一个字符串 s 和一个字符串字典 wordDict ，在字符串 s 中增加空格来构建一个句子，使得句子中所有的单词都在词典中。以任意顺序 返回所有这些可能的句子。 注意：词典中的同一个单词可能在分段中被重复使用多次。
LeetCode 第141题：环形链表
给你一个链表的头节点 head ，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。 如果链表中存在环，则返回 true 。 否则，返
LeetCode第100题：相同的树
给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。 如果两棵树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
LeetCode第101题：对称二叉树
给你一个二叉树的根节点 root ，检查它是否轴对称。
LeetCode第102题：二叉树的层序遍历
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
LeetCode第103题：二叉树的锯齿形层序遍历
给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
LeetCode第104题：二叉树的最大深度
给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。
LeetCode第105题：从前序与中序遍历序列构造二叉树
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的前序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。
LeetCode 第106题：从中序与后序遍历序列构造二叉树
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。
LeetCode 第107题：二叉树的层序遍历 II
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左到右遍历）
LeetCode 第108题：将有序数组转换为二叉搜索树
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。 高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。
LeetCode 第109题：有序链表转换二叉搜索树
给定一个单链表的头节点 head ，其中的元素 按升序排序 ，将其转换为高度平衡的二叉搜索树。 本题中，一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。
LeetCode 第110题：平衡二叉树
给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。
LeetCode 第111题：二叉树的最小深度
给定一个二叉树，找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 说明： 叶子节点是指没有子节点的节点。
LeetCode 第112题：路径总和
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。 叶子节点 是指没有子节点的节点。
LeetCode 第113题：路径总和 II
给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。 叶子节点 是指没有子节点的节点。
LeetCode 第114题：二叉树展开为链表
给你二叉树的根结点 root ，请你将它展开为一个单链表： - 展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。 - 展开后的单链表应该与二叉树 先序遍历 顺序相同。
LeetCode 第115题：不同的子序列
给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。 字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是） 题目数据保证答案符合 32 位带符号整数范围。
LeetCode 第116题：填充每个节点的下一个右侧节点指针
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下： struct Node { int val; Node left; Node right; Node next; } 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。 初始状态下，所有 n
LeetCode 第117题：填充每个节点的下一个右侧节点指针 II
给定一个二叉树： struct Node { int val; Node left; Node right; Node next; } 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。 初始状态下，所有 next 指针都被设置为 NULL。
LeetCode 第118题：杨辉三角
给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。 在「杨辉三角」中，每个数是它左上方和右上方的数的和。
LeetCode 第119题：杨辉三角 II
给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。 在「杨辉三角」中，每个数是它左上方和右上方的数的和。
LeetCode 第120题：三角形最小路径和
给定一个三角形 triangle ，找出自顶向下的最小路径和。 每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。
LeetCode 第31题：下一个排列
整数数组的一个 排列 就是将其所有成员以序列或线性顺序排列。 例如，arr = [1,2,3] ，以下这些都可以视作 arr 的排列：[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。 整数数组的 下一个排列 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 下一个排列 就是在
LeetCode 第32题：最长有效括号
给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。
LeetCode 第33题：搜索旋转排序数组
整数数组 nums 按升序排列，数组中的值 互不相同 。 在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如，
LeetCode 第34题：在排序数组中查找元素的第一个和最后一个位置
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。 如果数组中不存在目标值 target，返回 [-1, -1]。 你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
LeetCode 第35题：搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 请必须使用时间复杂度为 O(log n) 的算法。
LeetCode 第36题：有效的数独
请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。 1. 数字 1-9 在每一行只能出现一次。 2. 数字 1-9 在每一列只能出现一次。 3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图） 注意： - 一个有效的数独（部分已填）不一定是可解的。 - 只需要根据以上规则，验证
LeetCode 第37题：解数独
编写一个程序，通过填充空格来解决数独问题。 数独的解法需 遵循如下规则： 1. 数字 1-9 在每一行只能出现一次。 2. 数字 1-9 在每一列只能出现一次。 3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图） 数独部分空格内已填入了数字，空白格用 '.' 表示。
LeetCode 第38题：外观数列
给定一个正整数 n ，输出外观数列的第 n 项。 「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。 你可以将其视作是由递归公式定义的数字字符串序列： - countAndSay(1) = "1" - countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。 前五项如下： 1.
LeetCode 第39题：组合总和
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。 candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 对于给定的
LeetCode 第40题：组合总和 II
给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的每个数字在每个组合中只能使用 一次 。 注意： 解集不能包含重复的组合。
LeetCode 第41题：缺失的第一个正数
给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。 请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。
LeetCode 第42题：接雨水
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
LeetCode 第43题：字符串相乘
给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。 注意：不能使用任何内置的 BigInteger 库或直接将输入转换为整数。
LeetCode 第44题：通配符匹配
给定一个字符串 (s) 和一个字符模式 (p) ，实现一个支持 '?' 和 '' 的通配符匹配。 - '?' 可以匹配任何单个字符。 - '' 可以匹配任意字符序列（包括空序列）。 匹配应该覆盖整个字符串 (s) ，而不是部分字符串。
LeetCode 第45题：跳跃游戏 II
给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。 每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处: - 0 <= j <= nums[i] - i + j < n 返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例
LeetCode 第46题：全排列
给定一个不含重复数字的数组 nums ，返回其所有可能的全排列。你可以按任意顺序返回答案。
LeetCode 第47题：全排列 II
给定一个可包含重复数字的序列 nums ，按任意顺序返回所有不重复的全排列。
LeetCode 第48题：旋转图像
给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。 你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
LeetCode 第49题：字母异位词分组
给你一个字符串数组 strs，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。 字母异位词 是由重新排列源单词的所有字母得到的一个新单词。
LeetCode 第50题：Pow(x, n)
实现 pow(x, n)，即计算 x 的整数 n 次幂函数。
LeetCode 第51题：N 皇后
n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。 给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。 每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。
LeetCode 第52题：N皇后 II
n 皇后问题 研究的是如何将 n 个皇后放置在 n × n 的棋盘上，并且使皇后彼此之间不能相互攻击。 给你一个整数 n ，返回 n 皇后问题 不同的解决方案的数量。
LeetCode 第53题：最大子数组和
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 子数组 是数组中的一个连续部分。
LeetCode 第54题：螺旋矩阵
给你一个 m x n 的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
LeetCode 第55题：跳跃游戏
给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。 判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。
LeetCode 第56题：合并区间
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
LeetCode 第57题：插入区间
给你一个 无重叠的 ，按照区间起始端点排序的区间列表。在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。
LeetCode 第58题：最后一个单词的长度
给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。 单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
LeetCode 第59题：螺旋矩阵 II
给你一个正整数 n ，生成一个包含 1 到 n² 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
LeetCode 第60题：排列序列
给出集合 [1,2,3,...,n]，其所有元素共有 n! 种排列。 按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下： 1. "123" 2. "132" 3. "213" 4. "231" 5. "312" 6. "321" 给定 n 和 k，返回第 k 个排列。
LeetCode 第61题：旋转链表
给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。
LeetCode 第62题：不同路径
一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 "Start" ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 "Finish" ）。 问总共有多少条不同的路径？
LeetCode 第63题：不同路径 II
一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 "Start" ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 "Finish"）。 现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？ 网格中的障碍物和空位置分别用 1 和 0 来表示。
LeetCode 第64题：最小路径和
给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。 说明：每次只能向下或者向右移动一步。
LeetCode 第65题：有效数字
有效数字（按顺序）可以分成以下几个部分： 1. 一个 小数 或者 整数 2. （可选）一个 'e' 或 'E' ，后面跟着一个 整数 小数（按顺序）可以分成以下几个部分： 1. （可选）一个符号字符（'+' 或 '-'） 2. 下述格式之一： 1. 至少一位数字，后面跟着一个点 '.' 2. 至少一位数字，后面跟着一个点 '.' ，后面再跟着至少一位数字 3
LeetCode 第66题：加一
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。 最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。 你可以假设除了整数 0 之外，这个整数不会以零开头。
LeetCode 第67题：二进制求和
给你两个二进制字符串 a 和 b ，以二进制字符串的形式返回它们的和。
LeetCode 第68题：文本左右对齐
给定一个单词数组 words 和一个长度 maxWidth，重新排版单词，使其成为每行恰好有 maxWidth 个字符，且左右两端对齐的文本。 你应该使用"贪心"的方法来放置给定的单词；也就是说，尽可能多地往每行中放置单词。必要时可用空格 ' ' 填充，使得每行恰好有 maxWidth 个字符。 要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能
LeetCode 第69题：x的平方根
给你一个非负整数 x ，计算并返回 x 的 算术平方根 。 由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。 注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x 0.5 。
LeetCode 第70题：爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
LeetCode 第71题：简化路径
给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格绝对路径（以 '/' 开头），请你将其转化为更加简洁的规范路径。 在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点（..）表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠（即，//）都被视为单个斜杠 / 。 对于此问题，任
LeetCode 第72题：编辑距离
给你两个单词 word1 和 word2，请返回将 word1 转换成 word2 所使用的最少操作数。 你可以对一个单词进行如下三种操作： - 插入一个字符 - 删除一个字符 - 替换一个字符
LeetCode 第73题：矩阵置零
给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。
LeetCode第74题：搜索二维矩阵
编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有以下特性： - 每行中的整数从左到右按升序排列。 - 每行的第一个整数大于前一行的最后一个整数。
LeetCode第75题：颜色分类
给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。 此题中，我们使用整数 0、1 和 2 分别表示红色、白色和蓝色。 注意：不能使用代码库中的排序函数来解决这道题。
LeetCode第76题：最小覆盖子串
给你一个字符串 s 和一个字符串 t ，请你找出 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 ""。 注意： - 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。 - 如果 s 中存在这样的子串，我们保证它是唯一的答案。
LeetCode第77题：组合
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。
LeetCode第78题：子集
给你一个整数数组 nums，数组中的元素 互不相同。返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
LeetCode第79题：单词搜索
给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中"相邻"单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
LeetCode第80题：删除有序数组中的重复项 II
给你一个有序数组 nums ，请你原地删除重复出现的元素，使得每个元素最多出现两次，返回删除后数组的新长度。 不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
LeetCode第81题：搜索旋转排序数组 II
已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。 在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标从 0 开始计数）
LeetCode第82题：删除排序链表中的重复元素 II
给定一个已排序的链表的头 head ，删除原始链表中所有重复数字的节点，只留下不同的数字。返回已排序的链表。
LeetCode第83题：删除排序链表中的重复元素
给定一个已排序的链表的头 head ，删除所有重复的元素，使每个元素只出现一次。返回已排序的链表。
LeetCode第84题：柱状图中最大的矩形
给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。 求在该柱状图中，能够勾勒出来的矩形的最大面积。
LeetCode第85题：最大矩形
给定一个仅包含 0 和 1 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。
LeetCode第86题：分隔链表
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初始相对顺序。
LeetCode第87题：扰乱字符串
使用下面描述的算法可以扰乱字符串 s 得到字符串 t ： 1. 如果字符串的长度为 1 ，算法停止 2. 如果字符串的长度 > 1 ，执行下述步骤： - 在一个随机的索引处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。 - 随机 决定是要「交换两个子字符串」还是要「保持这两
LeetCode第88题：合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。 请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。 注意： 最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m +
LeetCode第89题：格雷编码
n 位格雷码序列 是一个由 2^n 个整数组成的序列，其中： - 每个整数都在范围 [0, 2^n - 1] 内（含 0 和 2^n - 1） - 第一个整数是 0 - 一个整数在序列中出现 不超过一次 - 每对 相邻 整数的二进制表示 恰好一位不同 ，且 - 第一个 和 最后一个 整数的二进制表示 恰好一位不同 给你一个整数 n ，返回任一有效的 n 位格
LeetCode第90题：子集 II
给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。
LeetCode第91题：解码方法
一条包含字母 A-Z 的消息通过以下映射进行了编码： 'A' -> "1" 'B' -> "2" ... 'Z' -> "26" 要解码已编码的消息，所有数字必须基于上述映射的方式，反向映射回字母（可能有多种方法）。例如，"11106" 可以映射为： - "AAJF" 对应于 (1 1 10 6) - "KJF" 对应于 (11 10 6) 注意，对应于 (
LeetCode第92题：反转链表 II
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回反转后的链表。
LeetCode第93题：复原IP地址
有效的 IP 地址由四个整数组成，整数之间用 . 分隔，其中每个整数位于 0 到 255 之间（包含 0 和 255），且不能含有前导零。 例如："0.1.2.201" 和 "192.168.1.1" 是有效的 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是无效的 IP 地址。 给定一个只
LeetCode第94题：二叉树的中序遍历
给定一个二叉树的根节点 root ，返回它的 中序 遍历。
LeetCode第95题：不同的二叉搜索树 II
给你一个整数 n ，请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同 二叉搜索树 。可以按 任意顺序 返回答案。
LeetCode第96题：不同的二叉搜索树
给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。
LeetCode第97题：交错字符串
给定三个字符串 s1、s2 和 s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错 组成的。 两个字符串 s 和 t 交错 的定义与过程如下，其中每个字符串都会被分割成若干 非空 子字符串： - s = s1 + s2 + ... + sn - t = t1 + t2 + ... + tm - |n - m| <= 1 - 交错 是 s1 + t1 +
LeetCode第98题：验证二叉搜索树
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。 有效二叉搜索树定义如下： - 节点的左子树只包含 小于 当前节点的数。 - 节点的右子树只包含 大于 当前节点的数。 - 所有左子树和右子树自身必须也是二叉搜索树。
LeetCode第99题：恢复二叉搜索树
给你二叉搜索树的根节点 root ，该树中的 恰好 两个节点的值被错误地交换。请在不改变其结构的情况下，恢复这棵树。
LeetCode 第1题：两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。 你可以按任意顺序返回答案。
LeetCode 第10题：正则表达式匹配
给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '' 的正则表达式匹配。 - '.' 匹配任意单个字符 - '' 匹配零个或多个前面的那一个元素 所谓匹配，是要涵盖 整个 字符串 s 的，而不是部分字符串。
LeetCode 第11题：盛最多水的容器
给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。 找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 返回容器可以储存的最大水量。 说明：你不能倾斜容器。
LeetCode 第12题：整数转罗马数字
给定一个整数，将其转换为罗马数字。 罗马数字包含以下七种字符： - I：1 - V：5 - X：10 - L：50 - C：100 - D：500 - M：1000 转换规则： 1. 基本规则是从大到小加法 2. 特殊规则（减法）： - 4：IV（5-1） - 9：IX（10-1） - 40：XL（50-10） - 90：XC（100-10） - 400：C
LeetCode 第13题：罗马数字转整数
给定一个罗马数字，将其转换成整数。 罗马数字包含以下七种字符： - I：1 - V：5 - X：10 - L：50 - C：100 - D：500 - M：1000 规则说明： 1. 通常情况下，罗马数字中小的数字在大的数字的右边 2. 特殊情况（减法规则）： - IV：4（5-1） - IX：9（10-1） - XL：40（50-10） - XC：90（1
LeetCode 第14题：最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 ""。
LeetCode 第15题：三数之和
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。 注意：答案中不可以包含重复的三元组。
LeetCode 第16题：最接近的三数之和
给你一个长度为 n 的整数数组 nums 和一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。 返回这三个数的和。 假定每组输入只存在恰好一个解。
LeetCode 第17题：电话号码的字母组合
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 - 2: abc - 3: def - 4: ghi - 5: jkl - 6: mno - 7: pqrs - 8: tuv - 9: wxyz
LeetCode 第18题：四数之和
给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）： - 0 <= a, b, c, d < n - a、b、c 和 d 互不相同 - nums[a] + num
LeetCode 第19题：删除链表的倒数第N个结点
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
LeetCode 第2题：两数相加
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
LeetCode 第20题：有效的括号
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。 有效字符串需满足： 1. 左括号必须用相同类型的右括号闭合。 2. 左括号必须以正确的顺序闭合。 3. 每个右括号都有一个对应的相同类型的左括号。
LeetCode 第21题：合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
LeetCode 第22题：括号生成
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
LeetCode 第23题：合并K个升序链表
给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。
LeetCode 第24题：两两交换链表中的节点
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
LeetCode 第25题：K 个一组翻转链表
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。 k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
LeetCode 第26题：删除有序数组中的重复项
给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。 由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。 将最终结果插入 num
LeetCode 第27题：移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
LeetCode 第28题：找出字符串中第一个匹配项的下标
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。
LeetCode 第29题：两数相除
给你两个整数，被除数 dividend 和除数 divisor。将两数相除，要求 不使用 乘法、除法和取余运算。 整数除法应该向零截断，也就是截去（truncate）其小数部分。例如，8.345 将被截断为 8 ，-2.7335 将被截断为 -2 。 返回被除数 dividend 除以除数 divisor 得到的 商 。 注意：假设我们的环境只能存储 32
LeetCode 第3题：无重复字符的最长子串
给定一个字符串 s ，请你找出其中不含有重复字符的最长子串的长度。
LeetCode 第30题：串联所有单词的子串
给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。 s 中的 串联子串 是指一个包含 words 中所有字符串以任意顺序排列连接起来的子串。 例如，如果 words = ["ab","cd","ef"]， 那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"， 和 "efcd
LeetCode 第4题：寻找两个正序数组的中位数
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数。 算法的时间复杂度应该为 O(log (m+n))。
LeetCode 第5题：最长回文子串
给你一个字符串 s，找到 s 中最长的回文子串。
LeetCode 第6题：Z字形变换
将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。 比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下： P A H N A P L S I I G Y I R 之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。 请你实现这个将字符串进行指
LeetCode 第7题：整数反转
给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。 如果反转后整数超过 32 位的有符号整数的范围 [−2³¹, 2³¹ − 1] ，就返回 0。 假设环境不允许存储 64 位整数（有符号或无符号）。
LeetCode 第8题：字符串转换整数 (atoi)
请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数。 函数 myAtoi(string s) 的算法需要按照以下步骤： 1. 读入字符串并丢弃无用的前导空格 2. 检查下一个字符是否为正负号，读取该字符（如果有） 3. 读取数字字符，直到遇到非数字字符或到达字符串末尾 4. 将前面读入的字符转换为整数，如果没
LeetCode 第9题：回文数
给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。 回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。 例如，121 是回文，而 123 不是。