题目列表
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0？请你找出所有和为 0 且不重复的三元组。
给你一个由 `'1'`（陆地）和 `'0'`（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 **示例 1：** **输入：**grid = [ ['1','1','1','1','0'], ['1','1','0','1','0'], ['1','1','0','0','0'], ['0','0','0','0','0'] ] **输出：**1 **示例 2：** **输入：**grid = [ ['1','1','0','0','0'], ['1','1','0','0','0'], ['0','0','1','0','0'], ['0','0','0','1','1'] ] **输出：**3
整数数组 `nums` 按升序排列，数组中的值 **互不相同** 。 在传递给函数之前，`nums` 在预先未知的某个下标 `k`（`0 <= k < nums.length`）上进行了 **向左旋转**，使数组变为 `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]`（下标 **从 0 开始** 计数）。例如， `[0,1,2,4,5,6,7]` 下标 `3` 上向左旋转后可能变为 `[4,5,6,7,0,1,2]` 。 给你 **旋转后** 的数组 `nums` 和一个整数 `target` ，如果 `nums` 中存在这个目标值 `target` ，则返回它的下标，否则返回 `-1` 。 你必须设计一个时间复杂度为 `O(log n)` 的算法解决此问题。 **示例 1：** **输入：**nums = [4,5,6,7,0,1,2], target = 0 **输出：**4 **示例 2：** **输入：**nums = [4,5,6,7,0,1,2], target =
给定一个不含重复数字的数组 `nums` ，返回其 _所有可能的全排列_ 。你可以 **按任意顺序** 返回答案。 **示例 1：** **输入：**nums = [1,2,3] **输出：**[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] **示例 2：** **输入：**nums = [0,1] **输出：**[[0,1],[1,0]] **示例 3：** **输入：**nums = [1] **输出：**[[1]] **提示：** - `1 <= nums.length <= 6` - `-10 <= nums[i] <= 10` - `nums` 中的所有整数 **互不相同**
给你两个按 **非递减顺序** 排列的整数数组 `nums1` 和 `nums2`，另有两个整数 `m` 和 `n` ，分别表示 `nums1` 和 `nums2` 中的元素数目。 请你 **合并** `nums2` 到 `nums1` 中，使合并后的数组同样按 **非递减顺序** 排列。 **注意：**最终，合并后数组不应由函数返回，而是存储在数组 `nums1` 中。为了应对这种情况，`nums1` 的初始长度为 `m + n`，其中前 `m` 个元素表示应合并的元素，后 `n` 个元素为 `0` ，应忽略。`nums2` 的长度为 `n` 。 **示例 1：** **输入：**nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3 **输出：**[1,2,2,3,5,6] **解释：**需要合并 [1,2,3] 和 [2,5,6] 。 合并结果是 [_**1**_,_**2**_,2,_**3**_,5,6] ，其中斜体加粗标注的为 nums1 中的元素。 **示例 2：** **输入：**nums1 = [1],
给定一个只包括 `'('`，`')'`，`'{'`，`'}'`，`'['`，`']'` 的字符串 `s` ，判断字符串是否有效。 有效字符串需满足： 1. 左括号必须用相同类型的右括号闭合。 2. 左括号必须以正确的顺序闭合。 3. 每个右括号都有一个对应的相同类型的左括号。 **示例 1：** **输入：**s = "()" **输出：**true **示例 2：** **输入：**s = "()[]{}" **输出：**true **示例 3：** **输入：**s = "(]" **输出：**false **示例 4：** **输入：**s = "([])" **输出：**true **示例 5：** **输入：**s = "([)]" **输出：**false **提示：** - `1 <= s.length <= 104` - `s` 仅由括号 `'()[]{}'` 组成
给定一个数组 `prices` ，它的第 `i` 个元素 `prices[i]` 表示一支给定股票第 `i` 天的价格。 你只能选择 **某一天** 买入这只股票，并选择在 **未来的某一个不同的日子** 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 `0` 。 **示例 1：** **输入：**[7,1,5,3,6,4] **输出：**5 **解释：**在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。 **示例 2：** **输入：**prices = [7,6,4,3,1] **输出：**0 **解释：**在这种情况下, 没有交易完成, 所以最大利润为 0。 **提示：** - `1 <= prices.length <= 105` - `0 <= prices[i] <= 104`
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 [百度百科](https://baike.baidu.com/item/%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/8918834?fr=aladdin)中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（**一个节点也可以是它自己的祖先**）。” **示例 1：**  **输入：**root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 **输出：**3 **解释：**节点 `5` 和节点 `1` 的最近公共祖先是节点 `3 。` **示例 2：** 
给你单链表的头指针 `head` 和两个整数 `left` 和 `right` ，其中 `left <= right` 。请你反转从位置 `left` 到位置 `right` 的链表节点，返回 **反转后的链表** 。 **示例 1：**  **输入：**head = [1,2,3,4,5], left = 2, right = 4 **输出：**[1,4,3,2,5] **示例 2：** **输入：**head = [5], left = 1, right = 1 **输出：**[5] **提示：** - 链表中节点数目为 `n` - `1 <= n <= 500` - `-500 <= Node.val <= 500` - `1 <= left <= right <= n` **进阶：** 你可以使用一趟扫描完成反转吗？
给你一个链表的头节点 `head` ，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 `next` 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 `pos` 来表示链表尾连接到链表中的位置（索引从 0 开始）。**注意：`pos` 不作为参数进行传递** 。仅仅是为了标识链表的实际情况。 _如果链表中存在环_ ，则返回 `true` 。 否则，返回 `false` 。 **示例 1：**  **输入：**head = [3,2,0,-4], pos = 1 **输出：**true **解释：**链表中有一个环，其尾部连接到第二个节点。 **示例 2：** )` 吗?
给你一个 `m` 行 `n` 列的矩阵 `matrix` ，请按照 **顺时针螺旋顺序** ，返回矩阵中的所有元素。 **示例 1：**  **输入：**matrix = [[1,2,3],[4,5,6],[7,8,9]] **输出：**[1,2,3,6,9,8,7,4,5] **示例 2：**  **输入：**matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]] **输出：**[1,2,3,4,8,12,11,10,9,5,6,7] **提示：** - `m == matrix.length` - `n == matrix[i].length` - `1 <= m, n <= 10` - `-100 <= matrix[i][j] <= 100`
给定一个单链表 `L` 的头节点 `head` ，单链表 `L` 表示为： L0 → L1 → … → Ln - 1 → Ln 请将其重新排列后变为： L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → … 不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 **示例 1：**  **输入：**head = [1,2,3,4] **输出：**[1,4,2,3] **示例 2：**  **输入：**head = [1,2,3,4,5] **输出：**[1,5,2,4,3] **提示：** - 链表的长度范围为 `[1, 5 * 104]` - `1 <= node.val <= 1000`
给你一个链表数组，每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中，返回合并后的链表。 **示例 1：** **输入：**lists = [[1,4,5],[1,3,4],[2,6]] **输出：**[1,1,2,3,4,4,5,6] **解释：**链表数组如下： [ 1->4->5, 1->3->4, 2->6 ] 将它们合并到一个有序链表中得到。 1->1->2->3->4->4->5->6 **示例 2：** **输入：**lists = [] **输出：**[] **示例 3：** **输入：**lists = [[]] **输出：**[] **提示：** - `k == lists.length` - `0 <= k <= 10^4` - `0 <= lists[i].length <= 500` - `-10^4 <= lists[i][j] <= 10^4` - `lists[i]` 按 **升序** 排列 - `lists[i].length` 的总和不超过 `10^4`
给定两个字符串形式的非负整数 `num1` 和`num2` ，计算它们的和并同样以字符串形式返回。 你不能使用任何內建的用于处理大整数的库（比如 `BigInteger`）， 也不能直接将输入的字符串转换为整数形式。 **示例 1：** **输入：**num1 = "11", num2 = "123" **输出：**"134" **示例 2：** **输入：**num1 = "456", num2 = "77" **输出：**"533" **示例 3：** **输入：**num1 = "0", num2 = "0" **输出：**"0" **提示：** - `1 <= num1.length, num2.length <= 104` - `num1` 和`num2` 都只包含数字 `0-9` - `num1` 和`num2` 都不包含任何前导零
以数组 `intervals` 表示若干个区间的集合，其中单个区间为 `intervals[i] = [starti, endi]` 。请你合并所有重叠的区间，并返回 _一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间_ 。 **示例 1：** **输入：**intervals = [[1,3],[2,6],[8,10],[15,18]] **输出：**[[1,6],[8,10],[15,18]] **解释：**区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6]. **示例 2：** **输入：**intervals = [[1,4],[4,5]] **输出：**[[1,5]] **解释：**区间 [1,4] 和 [4,5] 可被视为重叠区间。 **示例 3：** **输入：**intervals = [[4,7],[1,4]] **输出：**[[1,7]] **解释：**区间 [1,4] 和 [4,7] 可被视为重叠区间。 **提示：** - `1 <= intervals.length <= 104` - `intervals[i].leng
给你两个单链表的头节点 `headA` 和 `headB` ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 `null` 。 图示两个链表在节点 `c1` 开始相交**：** [](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_statement.png) 题目数据 **保证** 整个链式结构中不存在环。 **注意**，函数返回结果后，链表必须 **保持其原始结构** 。 **自定义评测：** **评测系统** 的输入如下（你设计的程序 **不适用** 此输入）： - `intersectVal` - 相交的起始节点的值。如果不存在相交节点，这一值为 `0` - `listA` - 第一个链表 - `listB` - 第二个链表 - `skipA` - 在 `listA`
给定 `n` 个非负整数表示每个宽度为 `1` 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。 **示例 1：**  **输入：**height = [0,1,0,2,1,0,1,3,2,1,2,1] **输出：**6 **解释：**上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 **示例 2：** **输入：**height = [4,2,0,3,2,5] **输出：**9 **提示：** - `n == height.length` - `1 <= n <= 2 * 104` - `0 <= height[i] <= 105`
给定两个字符串 `text1` 和 `text2`，返回这两个字符串的最长 **公共子序列** 的长度。如果不存在 **公共子序列** ，返回 `0` 。 一个字符串的 **子序列** 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。 - 例如，`"ace"` 是 `"abcde"` 的子序列，但 `"aec"` 不是 `"abcde"` 的子序列。 两个字符串的 **公共子序列** 是这两个字符串所共同拥有的子序列。 **示例 1：** **输入：**text1 = "abcde", text2 = "ace" **输出：**3 **解释：**最长公共子序列是 "ace" ，它的长度为 3 。 **示例 2：** **输入：**text1 = "abc", text2 = "abc" **输出：**3 **解释：**最长公共子序列是 "abc" ，它的长度为 3 。 **示例 3：** **输入：**text1 = "abc", text2 = "def" **输出：**0 **解释：
二叉树中的 **路径** 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 **至多出现一次** 。该路径 **至少包含一个** 节点，且不一定经过根节点。 **路径和** 是路径中各节点值的总和。 给你一个二叉树的根节点 `root` ，返回其 **最大路径和** 。 **示例 1：**  **输入：**root = [1,2,3] **输出：**6 **解释：**最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6 **示例 2：**  **输入：**root = [-10,9,20,null,null,15,7] **输出：**42 **解释：**最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42 **提示：** - 树中节点数目范
**有效 IP 地址** 正好由四个整数（每个整数位于 `0` 到 `255` 之间组成，且不能含有前导 `0`），整数之间用 `'.'` 分隔。 - 例如：`"0.1.2.201"` 和 `"192.168.1.1"` 是 **有效** IP 地址，但是 `"0.011.255.245"`、`"192.168.1.312"` 和 `"192.168@1.1"` 是 **无效** IP 地址。 给定一个只包含数字的字符串 `s` ，用以表示一个 IP 地址，返回所有可能的**有效 IP 地址**，这些地址可以通过在 `s` 中插入 `'.'` 来形成。你 **不能** 重新排序或删除 `s` 中的任何数字。你可以按 **任何** 顺序返回答案。 **示例 1：** **输入：**s = "25525511135" **输出：**["255.255.11.135","255.255.111.35"] **示例 2：** **输入：**s = "0000" **输出：**["0.0.0.0"] **示例 3：** **输入：**s = "101023" **输出：**["
给定一个已排序的链表的头 `head` ， _删除原始链表中所有重复数字的节点，只留下不同的数字_ 。返回 _已排序的链表_ 。 **示例 1：**  **输入：**head = [1,2,3,3,4,4,5] **输出：**[1,2,5] **示例 2：**  **输入：**head = [1,1,1,2,3] **输出：**[2,3] **提示：** - 链表中节点数目在范围 `[0, 300]` 内 - `-100 <= Node.val <= 100` - 题目数据保证链表已经按升序 **排列**
给你一个链表，删除链表的倒数第 `n` 个结点，并且返回链表的头结点。 **示例 1：**  **输入：**head = [1,2,3,4,5], n = 2 **输出：**[1,2,3,5] **示例 2：** **输入：**head = [1], n = 1 **输出：**[] **示例 3：** **输入：**head = [1,2], n = 1 **输出：**[1]
给定一个链表的头节点 `head` ，返回链表开始入环的第一个节点。 _如果链表无环，则返回 `null`。_ 如果链表中有某个节点，可以通过连续跟踪 `next` 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 `pos` 来表示链表尾连接到链表中的位置（**索引从 0 开始**）。如果 `pos` 是 `-1`，则在该链表中没有环。**注意：`pos` 不作为参数进行传递**，仅仅是为了标识链表的实际情况。 **不允许修改** 链表。 **示例 1：**  **输入：**head = [3,2,0,-4], pos = 1 **输出：**返回索引为 1 的链表节点 **解释：**链表中有一个环，其尾部连接到第二个节点。 **示例 2：** )` 。 **示例 1：** **输入：**nums1 = [1,3], nums2 = [2] **输出：**2.00000 **解释：**合并数组 = [1,2,3] ，中位数 2 **示例 2：** **输入：**nums1 = [1,2], nums2 = [3,4] **输出：**2.50000 **解释：**合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5 **提示：** - `nums1.length == m` - `nums2.length == n` - `0 <= m <= 1000` - `0 <= n <= 1000` - `1 <= m + n <= 2000` - `-106 <= nums1[i], nums2[i] <= 106`
给定一个二叉树的 **根节点** `root`，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。 **示例 1：** **输入：**root = [1,2,3,null,5,null,4] **输出：**[1,3,4] **解释：**  **示例 2：** **输入：**root = [1,2,3,4,null,null,null,5] **输出：**[1,3,4,5] **解释：**  **示例 3：** **输入：**root = [1,null,3] **输出：**[1,3] **示例 4：** **输入：**root = [] **输出：**[] **提示:** - 二叉树的节点个数的范围是 `[0,100]` - `-100 <= Node.
给你两个 **版本号字符串** `version1` 和 `version2` ，请你比较它们。版本号由被点 `'.'` 分开的修订号组成。**修订号的值** 是它 **转换为整数** 并忽略前导零。 比较版本号时，请按 **从左到右的顺序** 依次比较它们的修订号。如果其中一个版本字符串的修订号较少，则将缺失的修订号视为 `0`。 返回规则如下： - 如果 `_version1_ _version2_` 返回 `1`， - 除此之外返回 `0`。 **示例 1：** **输入：**version1 = "1.2", version2 = "1.10" **输出：**-1 **解释：** version1 的第二个修订号为 "2"，version2 的第二个修订号为 "10"：2 < 10，所以 version1 < version2。 **示例 2：** **输入：**version1 = "1.01", version2 = "1.001" **输出：**0 **解释：** 忽略前导零，"01" 和 "001" 都代表相同的整数 "1"。 **示例
给定一个 `n` 个元素有序的（升序）整型数组 `nums` 和一个目标值 `target` ，写一个函数搜索 `nums` 中的 `target`，如果 `target` 存在返回下标，否则返回 `-1`。 你必须编写一个具有 `O(log n)` 时间复杂度的算法。 **示例 1:** **输入:** `nums` = [-1,0,3,5,9,12], `target` = 9 **输出:** 4 **解释:** 9 出现在 `nums` 中并且下标为 4 **示例 2:** **输入:** `nums` = [-1,0,3,5,9,12], `target` = 2 **输出:** -1 **解释:** 2 不存在 `nums` 中因此返回 -1 **提示：** 1. 你可以假设 `nums` 中的所有元素是不重复的。 2. `n` 将在 `[1, 10000]`之间。 3. `nums` 的每个元素都将在 `[-9999, 9999]`之间。
数字 `n` 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 **有效的** 括号组合。 **示例 1：** **输入：**n = 3 **输出：**["((()))","(()())","(())()","()(())","()()()"] **示例 2：** **输入：**n = 1 **输出：**["()"] **提示：** - `1 <= n <= 8`
给定一个二叉树的根节点 `root` ，返回 _它的 **中序** 遍历_ 。 **示例 1：**  **输入：**root = [1,null,2,3] **输出：**[1,3,2] **示例 2：** **输入：**root = [] **输出：**[] **示例 3：** **输入：**root = [1] **输出：**[1] **提示：** - 树中节点数目在范围 `[0, 100]` 内 - `-100 <= Node.val <= 100` **进阶:** 递归算法很简单，你可以通过迭代算法完成吗？
给你一个整数数组 `nums`，有一个大小为 `k` 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 `k` 个数字。滑动窗口每次只向右移动一位。 返回 _滑动窗口中的最大值_ 。 **示例 1：** **输入：**nums = [1,3,-1,-3,5,3,6,7], k = 3 **输出：**[3,3,5,5,6,7] **解释：** 滑动窗口的位置 最大值 --------------- ----- [1 3 -1] -3 5 3 6 7 **3** 1 [3 -1 -3] 5 3 6 7 **3** 1 3 [-1 -3 5] 3 6 7 ** 5** 1 3 -1 [-3 5 3] 6 7 **5** 1 3 -1 -3 [5 3 6] 7 **6** 1 3 -1 -3 5 [3 6 7] **7** **示例 2：** **输入：**num
给你一个非负整数 `x` ，计算并返回 `x` 的 **算术平方根** 。 由于返回类型是整数，结果只保留 **整数部分** ，小数部分将被 **舍去 。** **注意：**不允许使用任何内置指数函数和算符，例如 `pow(x, 0.5)` 或者 `x ** 0.5` 。 **示例 1：** **输入：**x = 4 **输出：**2 **示例 2：** **输入：**x = 8 **输出：**2 **解释：**8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。 **提示：** - `0 <= x <= 231 - 1`
给你链表的头结点 `head` ，请将其按 **升序** 排列并返回 **排序后的链表** 。 **示例 1：**  **输入：**head = [4,2,1,3] **输出：**[1,2,3,4] **示例 2：**  **输入：**head = [-1,5,3,4,0] **输出：**[-1,0,3,4,5] **示例 3：** **输入：**head = [] **输出：**[] **提示：** - 链表中节点的数目在范围 `[0, 5 * 104]` 内 - `-105 <= Node.val <= 105` **进阶：**你可以在 `O(n log n)` 时间复杂度和常数级空间复杂度下，对链表进行排序吗？
给你一个只包含 `'('` 和 `')'` 的字符串，找出最长有效（格式正确且连续）括号 子串 的长度。 左右括号匹配，即每个左括号都有对应的右括号将其闭合的字符串是格式正确的，比如 `"(()())"`。 **示例 1：** **输入：**s = "(()" **输出：**2 **解释：**最长有效括号子串是 "()" **示例 2：** **输入：**s = ")()())" **输出：**4 **解释：**最长有效括号子串是 "()()" **示例 3：** **输入：**s = "" **输出：**0 **提示：** - `0 <= s.length <= 3 * 104` - `s[i]` 为 `'('` 或 `')'`
整数数组的一个 **排列** 就是将其所有成员以序列或线性顺序排列。 - 例如，`arr = [1,2,3]` ，以下这些都可以视作 `arr` 的排列：`[1,2,3]`、`[1,3,2]`、`[3,1,2]`、`[2,3,1]` 。 整数数组的 **下一个排列** 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 **下一个排列** 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。 - 例如，`arr = [1,2,3]` 的下一个排列是 `[1,3,2]` 。 - 类似地，`arr = [2,3,1]` 的下一个排列是 `[3,1,2]` 。 - 而 `arr = [3,2,1]` 的下一个排列是 `[1,2,3]` ，因为 `[3,2,1]` 不存在一个字典序更大的排列。 给你一个整数数组 `nums` ，找出 `nums` 的下一个排列。 必须 **[原地](https://baike.baidu.com/ite
请你来实现一个 `myAtoi(string s)` 函数，使其能将字符串转换成一个 32 位有符号整数。 函数 `myAtoi(string s)` 的算法如下： 1. **空格：**读入字符串并丢弃无用的前导空格（`" "`） 2. **符号：**检查下一个字符（假设还未到字符末尾）为 `'-'` 还是 `'+'`。如果两者都不存在，则假定结果为正。 3. **转换：**通过跳过前置零来读取该整数，直到遇到非数字字符或到达字符串的结尾。如果没有读取数字，则结果为0。 4. **舍入：**如果整数数超过 32 位有符号整数范围 `[−231, 231 − 1]` ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 `−231` 的整数应该被舍入为 `−231` ，大于 `231 − 1` 的整数应该被舍入为 `231 − 1` 。 返回整数作为最终结果。 **示例 1：** **输入：**s = "42" **输出：**42 **解释：**加粗的字符串为已经读入的字符，插入符号是当前读取的字符。 带下划线线的字符是所读的内容，插入符号是当前读入位置。 第 1
假设你正在爬楼梯。需要 `n` 阶你才能到达楼顶。 每次你可以爬 `1` 或 `2` 个台阶。你有多少种不同的方法可以爬到楼顶呢？ **示例 1：** **输入：**n = 2 **输出：**2 **解释：**有两种方法可以爬到楼顶。 1. 1 阶 + 1 阶 2. 2 阶 **示例 2：** **输入：**n = 3 **输出：**3 **解释：**有三种方法可以爬到楼顶。 1. 1 阶 + 1 阶 + 1 阶 2. 1 阶 + 2 阶 3. 2 阶 + 1 阶 **提示：** - `1 <= n <= 45`
给你一个整数数组 `coins` ，表示不同面额的硬币；以及一个整数 `amount` ，表示总金额。 计算并返回可以凑成总金额所需的 **最少的硬币个数** 。如果没有任何一种硬币组合能组成总金额，返回 `-1` 。 你可以认为每种硬币的数量是无限的。 **示例 1：** **输入：**coins = `[1, 2, 5]`, amount = `11` **输出：**`3` **解释：**11 = 5 + 5 + 1 **示例 2：** **输入：**coins = `[2]`, amount = `3` **输出：**-1 **示例 3：** **输入：**coins = [1], amount = 0 **输出：**0 **提示：** - `1 <= coins.length <= 12` - `1 <= coins[i] <= 231 - 1` - `0 <= amount <= 104`
给定两个以字符串形式表示的非负整数 `num1` 和 `num2`，返回 `num1` 和 `num2` 的乘积，它们的乘积也表示为字符串形式。 **注意：**不能使用任何内置的 BigInteger 库或直接将输入转换为整数。 **示例 1:** **输入:** num1 = "2", num2 = "3" **输出:** "6" **示例 2:** **输入:** num1 = "123", num2 = "456" **输出:** "56088" **提示：** - `1 <= num1.length, num2.length <= 200` - `num1` 和 `num2` 只能由数字组成。 - `num1` 和 `num2` 都不包含任何前导零，除了数字0本身。
给你一个字符串 `s` 、一个字符串 `t` 。返回 `s` 中涵盖 `t` 所有字符的最小子串。如果 `s` 中不存在涵盖 `t` 所有字符的子串，则返回空字符串 `""` 。 **注意：** - 对于 `t` 中重复字符，我们寻找的子字符串中该字符数量必须不少于 `t` 中该字符数量。 - 如果 `s` 中存在这样的子串，我们保证它是唯一的答案。 **示例 1：** **输入：**s = "ADOBECODEBANC", t = "ABC" **输出：**"BANC" **解释：**最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。 **示例 2：** **输入：**s = "a", t = "a" **输出：**"a" **解释：**整个字符串 s 是最小覆盖子串。 **示例 3:** **输入:** s = "a", t = "aa" **输出:** "" **解释:** t 中两个字符 'a' 均应包含在 s 的子串中， 因此没有符合条件的子字符串，返回空字符串。 **提示：** - `m == s.length` - `n
给你一个未排序的整数数组 `nums` ，请你找出其中没有出现的最小的正整数。 请你实现时间复杂度为 `O(n)` 并且只使用常数级别额外空间的解决方案。 **示例 1：** **输入：**nums = [1,2,0] **输出：**3 **解释：**范围 [1,2] 中的数字都在数组中。 **示例 2：** **输入：**nums = [3,4,-1,1] **输出：**2 **解释：**1 在数组中，但 2 没有。 **示例 3：** **输入：**nums = [7,8,9,11,12] **输出：**1 **解释：**最小的正数 1 没有出现。 **提示：** - `1 <= nums.length <= 105` - `-231 <= nums[i] <= 231 - 1`
给定两个整数数组 `preorder` 和 `inorder` ，其中 `preorder` 是二叉树的**先序遍历**， `inorder` 是同一棵树的**中序遍历**，请构造二叉树并返回其根节点。 **示例 1:**  **输入****:** preorder = [3,9,20,15,7], inorder = [9,3,15,20,7] **输出:** [3,9,20,null,null,15,7] **示例 2:** **输入:** preorder = [-1], inorder = [-1] **输出:** [-1] **提示:** - `1 <= preorder.length <= 3000` - `inorder.length == preorder.length` - `-3000 <= preorder[i], inorder[i] <= 3000` - `preorder` 和 `inorder` 均 **无重复** 元素
给你一个整数数组 `nums` ，数组中的元素 **互不相同** 。返回该数组所有可能的子集（幂集）。 解集 **不能** 包含重复的子集。你可以按 **任意顺序** 返回解集。 **示例 1：** **输入：**nums = [1,2,3] **输出：**[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]] **示例 2：** **输入：**nums = [0] **输出：**[[],[0]] **提示：** - `1 <= nums.length <= 10` - `-10 <= nums[i] <= 10` - `nums` 中的所有元素 **互不相同**
给你一个字符串 `s` ，请你反转字符串中 **单词** 的顺序。 **单词** 是由非空格字符组成的字符串。`s` 中使用至少一个空格将字符串中的 **单词** 分隔开。 返回 **单词** 顺序颠倒且 **单词** 之间用单个空格连接的结果字符串。 **注意：**输入字符串 `s`中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。 **示例 1：** **输入：**s = "the sky is blue" **输出：**"blue is sky the" **示例 2：** **输入：**s = " hello world " **输出：**"world hello" **解释：**反转后的字符串中不能存在前导空格和尾随空格。 **示例 3：** **输入：**s = "a good example" **输出：**"example good a" **解释：**如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。 **提示：** - `1 <= s.
设计一个支持 `push` ，`pop` ，`top` 操作，并能在常数时间内检索到最小元素的栈。 实现 `MinStack` 类: - `MinStack()` 初始化堆栈对象。 - `void push(int val)` 将元素val推入堆栈。 - `void pop()` 删除堆栈顶部的元素。 - `int top()` 获取堆栈顶部的元素。 - `int getMin()` 获取堆栈中的最小元素。 **示例 1:** **输入：** ["MinStack","push","push","push","getMin","pop","top","getMin"] [[],[-2],[0],[-3],[],[],[],[]] **输出：** [null,null,null,null,-3,null,0,-2] **解释：** MinStack minStack = new MinStack(); minStack.push(-2); minStack.push(0); minStack.push(-3); minStack.getMin(); --> 返回 -3.
给你一个按照非递减顺序排列的整数数组 `nums`，和一个目标值 `target`。请你找出给定目标值在数组中的开始位置和结束位置。 如果数组中不存在目标值 `target`，返回 `[-1, -1]`。 你必须设计并实现时间复杂度为 `O(log n)` 的算法解决此问题。 **示例 1：** **输入：**nums = [`5,7,7,8,8,10]`, target = 8 **输出：**[3,4] **示例 2：** **输入：**nums = [`5,7,7,8,8,10]`, target = 6 **输出：**[-1,-1] **示例 3：** **输入：**nums = [], target = 0 **输出：**[-1,-1] **提示：** - `0 <= nums.length <= 105` - `-109 <= nums[i] <= 109` - `nums` 是一个非递减数组 - `-109 <= target <= 109`
给定一个经过编码的字符串，返回它解码后的字符串。 编码规则为: `k[encoded_string]`，表示其中方括号内部的 `encoded_string` 正好重复 `k` 次。注意 `k` 保证为正整数。 你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。 此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 `k` ，例如不会出现像 `3a` 或 `2[4]` 的输入。 测试用例保证输出的长度不会超过 `105`。 **示例 1：** **输入：**s = "3[a]2[bc]" **输出：**"aaabcbc" **示例 2：** **输入：**s = "3[a2[c]]" **输出：**"accaccacc" **示例 3：** **输入：**s = "2[abc]3[cd]ef" **输出：**"abcabccdcdcdef" **示例 4：** **输入：**s = "abc3[cd]xyz" **输出：**"abccdcdcdxyz" **提示：** - `1 <= s.length
给你一个二叉树的根节点 `root` ， 检查它是否轴对称。 **示例 1：**  **输入：**root = [1,2,2,3,4,4,3] **输出：**true **示例 2：**  **输入：**root = [1,2,2,null,3,null,3] **输出：**false **提示：** - 树中节点数目在范围 `[1, 1000]` 内 - `-100 <= Node.val <= 100` **进阶：**你可以运用递归和迭代两种方法解决这个问题吗？
给你一个 **无重复元素** 的整数数组 `candidates` 和一个目标整数 `target` ，找出 `candidates` 中可以使数字和为目标数 `target` 的 所有 **不同组合** ，并以列表形式返回。你可以按 **任意顺序** 返回这些组合。 `candidates` 中的 **同一个** 数字可以 **无限制重复被选取** 。如果至少一个数字的被选数量不同，则两种组合是不同的。 对于给定的输入，保证和为 `target` 的不同组合数少于 `150` 个。 **示例 1：** **输入：**candidates = [2,3,6,7], target = 7 **输出：**[[2,2,3],[7]] **解释：** 2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。 7 也是一个候选， 7 = 7 。 仅有这两种组合。 **示例 2：** **输入:** candidates = [2,3,5], target = 8 **输出:** [[2,2,2,2],[2,3,3],[3,5]] **示例 3：**
给定方法 `rand7` 可生成 `[1,7]` 范围内的均匀随机整数，试写一个方法 `rand10` 生成 `[1,10]` 范围内的均匀随机整数。 你只能调用 `rand7()` 且不能调用其他方法。请不要使用系统的 `Math.random()` 方法。 每个测试用例将有一个内部参数 `n`，即你实现的函数 `rand10()` 在测试时将被调用的次数。请注意，这不是传递给 `rand10()` 的参数。 **示例 1:** **输入:** 1 **输出:** [2] **示例 2:** **输入:** 2 **输出:** [2,8] **示例 3:** **输入:** 3 **输出:** [3,8,10] **提示:** - `1 <= n <= 105` **进阶:** - `rand7()`调用次数的 [期望值](https://en.wikipedia.org/wiki/Expected_value) 是多少 ? - 你能否尽量少调用 `rand7()` ?
给定一个包含非负整数的 `_m_ x _n_` 网格 `grid` ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。 **说明：**每次只能向下或者向右移动一步。 **示例 1：**  **输入：**grid = [[1,3,1],[1,5,1],[4,2,1]] **输出：**7 **解释：**因为路径 1→3→1→1→1 的总和最小。 **示例 2：** **输入：**grid = [[1,2,3],[4,5,6]] **输出：**12 **提示：** - `m == grid.length` - `n == grid[i].length` - `1 <= m, n <= 200` - `0 <= grid[i][j] <= 200`
给定一个二叉树 `root` ，返回其最大深度。 二叉树的 **最大深度** 是指从根节点到最远叶子节点的最长路径上的节点数。 **示例 1：**  **输入：**root = [3,9,20,null,null,15,7] **输出：**3 **示例 2：** **输入：**root = [1,null,2] **输出：**2 **提示：** - 树中节点的数量在 `[0, 104]` 区间内。 - `-100 <= Node.val <= 100`
给定一个二叉树，判断它是否是 平衡二叉树 **示例 1：**  **输入：**root = [3,9,20,null,null,15,7] **输出：**true **示例 2：**  **输入：**root = [1,2,2,3,3,null,null,4,4] **输出：**false **示例 3：** **输入：**root = [] **输出：**true **提示：** - 树中的节点数在范围 `[0, 5000]` 内 - `-104 <= Node.val <= 104`
给你二叉树的根节点 `root` ，返回它节点值的 **前序** 遍历。 **示例 1：** **输入：**root = [1,null,2,3] **输出：**[1,2,3] **解释：**  **示例 2：** **输入：**root = [1,2,3,4,5,null,8,null,null,6,7,9] **输出：**[1,2,4,5,6,7,3,8,9] **解释：**  **示例 3：** **输入：**root = [] **输出：**[] **示例 4：** **输入：**root = [1] **输出：**[1] **提示：** - 树中节点数目在范围 `[0, 100]` 内 - `-100 <= Node.val <= 100` **进阶
给定一个 _n_ × _n_ 的二维矩阵 `matrix` 表示一个图像。请你将图像顺时针旋转 90 度。 你必须在 **[原地](https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95)** 旋转图像，这意味着你需要直接修改输入的二维矩阵。**请不要** 使用另一个矩阵来旋转图像。 **示例 1：**  **输入：**matrix = [[1,2,3],[4,5,6],[7,8,9]] **输出：**[[7,4,1],[8,5,2],[9,6,3]] **示例 2：**  **输入：**matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]] **输出：**[[15,13,2,5],[14,3,4,1
给你一个单链表的头节点 `head` ，请你判断该链表是否为回文链表。如果是，返回 `true` ；否则，返回 `false` 。 **示例 1：**  **输入：**head = [1,2,2,1] **输出：**true **示例 2：**  **输入：**head = [1,2] **输出：**false **提示：** - 链表中节点数目在范围`[1, 105]` 内 - `0 <= Node.val <= 9` **进阶：**你能否用 `O(n)` 时间复杂度和 `O(1)` 空间复杂度解决此题？
给你一个大小为 `m x n` 的二进制矩阵 `grid` 。 **岛屿** 是由一些相邻的 `1` (代表土地) 构成的组合，这里的「相邻」要求两个 `1` 必须在 **水平或者竖直的四个方向上** 相邻。你可以假设 `grid` 的四个边缘都被 `0`（代表水）包围着。 岛屿的面积是岛上值为 `1` 的单元格的数目。 计算并返回 `grid` 中最大的岛屿面积。如果没有岛屿，则返回面积为 `0` 。 **示例 1：**  **输入：**grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0
给你一个整数数组 `prices` ，其中 `prices[i]` 表示某支股票第 `i` 天的价格。 在每一天，你可以决定是否购买和/或出售股票。你在任何时候 **最多** 只能持有 **一股** 股票。然而，你可以在 **同一天** 多次买卖该股票，但要确保你持有的股票不超过一股。 返回 _你能获得的 **最大** 利润_ 。 **示例 1：** **输入：**prices = [7,1,5,3,6,4] **输出：**7 **解释：**在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。 随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。 最大总利润为 4 + 3 = 7 。 **示例 2：** **输入：**prices = [1,2,3,4,5] **输出：**4 **解释：**在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润
编写一个高效的算法来搜索 `_m_ x _n_` 矩阵 `matrix` 中的一个目标值 `target` 。该矩阵具有以下特性： - 每行的元素从左到右升序排列。 - 每列的元素从上到下升序排列。 **示例 1：**  **输入：**matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5 **输出：**true **示例 2：**  **输入：**matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18
在一个由 `'0'` 和 `'1'` 组成的二维矩阵内，找到只包含 `'1'` 的最大正方形，并返回其面积。 **示例 1：**  **输入：**matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]] **输出：**4 **示例 2：**  **输入：**matrix = [["0","1"],["1","0"]] **输出：**1 **示例 3：** **输入：**matrix = [["0"]] **输出：**0 **提示：** - `m == matrix.length` - `n == matrix[i].length` - `1 <= m, n <= 300` -
给你一个二叉树的根节点 `root` ，判断其是否是一个有效的二叉搜索树。 **有效** 二叉搜索树定义如下： - 节点的左子树只包含 **严格小于** 当前节点的数。 - 节点的右子树只包含 **严格大于** 当前节点的数。 - 所有左子树和右子树自身必须也是二叉搜索树。 **示例 1：**  **输入：**root = [2,1,3] **输出：**true **示例 2：**  **输入：**root = [5,1,4,null,null,3,6] **输出：**false **解释：**根节点的值是 5 ，但是右子节点的值是 4 。 **提示：** - 树中节点数目范围在`[1, 104]` 内 - `-231 <= Node.val <= 231 - 1`
给你一棵二叉树的根节点，返回该树的 **直径** 。 二叉树的 **直径** 是指树中任意两个节点之间最长路径的 **长度** 。这条路径可能经过也可能不经过根节点 `root` 。 两节点之间路径的 **长度** 由它们之间边数表示。 **示例 1：**  **输入：**root = [1,2,3,4,5] **输出：**3 **解释：**3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。 **示例 2：** **输入：**root = [1,2] **输出：**1 **提示：** - 树中节点数目在范围 `[1, 104]` 内 - `-100 <= Node.val <= 100`
编写一个函数来查找字符串数组中的最长公共前缀。 如果不存在公共前缀，返回空字符串 `""`。 **示例 1：** **输入：**strs = ["flower","flow","flight"] **输出：**"fl" **示例 2：** **输入：**strs = ["dog","racecar","car"] **输出：**"" **解释：**输入不存在公共前缀。 **提示：** - `1 <= strs.length <= 200` - `0 <= strs[i].length <= 200` - `strs[i]` 如果非空，则仅由小写英文字母组成
给定一组非负整数 `nums`，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。 **注意：**输出结果可能非常大，所以你需要返回一个字符串而不是整数。 **示例 1：** **输入`：`**`nums = [10,2]` **输出：**`"210"` **示例 2：** **输入`：`**`nums = [3,30,34,5,9]` **输出：**`"9534330"` **提示：** - `1 <= nums.length <= 100` - `0 <= nums[i] <= 109`
给你二叉树的根节点 `root` 和一个整数目标和 `targetSum` ，找出所有 **从根节点到叶子节点** 路径总和等于给定目标和的路径。 **叶子节点** 是指没有子节点的节点。 **示例 1：**  **输入：**root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22 **输出：**[[5,4,11,2],[5,8,4,5]] **示例 2：**  **输入：**root = [1,2,3], targetSum = 5 **输出：**[] **示例 3：** **输入：**root = [1,2], targetSum = 0 **输出：**[] **提示：** - 树中节点总数在范围 `[0, 5000]` 内 - `-10
给你一棵二叉树的根节点 `root` ，返回树的 **最大宽度** 。 树的 **最大宽度** 是所有层中最大的 **宽度** 。 每一层的 **宽度** 被定义为该层最左和最右的非空节点（即，两个端点）之间的长度。将这个二叉树视作与满二叉树结构相同，两端点间会出现一些延伸到这一层的 `null` 节点，这些 `null` 节点也计入长度。 题目数据保证答案将会在 **32 位** 带符号整数范围内。 **示例 1：**  **输入：**root = [1,3,2,5,3,null,9] **输出：**4 **解释：**最大宽度出现在树的第 3 层，宽度为 4 (5,3,null,9) 。 **示例 2：**  **输入：**root = [1,3,2,5,nu
一个机器人位于一个 `m x n` 网格的左上角 （起始点在下图中标记为 “Start” ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。 问总共有多少条不同的路径？ **示例 1：**  **输入：**m = 3, n = 7 **输出：**28 **示例 2：** **输入：**m = 3, n = 2 **输出：**3 **解释：** 从左上角开始，总共有 3 条路径可以到达右下角。 1. 向右 -> 向下 -> 向下 2. 向下 -> 向下 -> 向右 3. 向下 -> 向右 -> 向下 **示例 3：** **输入：**m = 7, n = 3 **输出：**28 **示例 4：** **输入：**m = 3, n = 3 **输出：**6 **提示：** - `1 <= m, n <= 100` - 题目数据保证答案小于等于 `2 * 109`
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，**如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警**。 给定一个代表每个房屋存放金额的非负整数数组，计算你 **不触动警报装置的情况下** ，一夜之内能够偷窃到的最高金额。 **示例 1：** **输入：**[1,2,3,1] **输出：**4 **解释：**偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 偷窃到的最高金额 = 1 + 3 = 4 。 **示例 2：** **输入：**[2,7,9,3,1] **输出：**12 **解释：**偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。 偷窃到的最高金额 = 2 + 9 + 1 = 12 。 **提示：** - `1 <= nums.length <= 100` - `0 <= nums[i] <= 400`
给你一个整数数组 `nums` ，请你找出数组中乘积最大的非空连续 子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。 测试用例的答案是一个 **32-位** 整数。 **请注意**，一个只包含一个元素的数组的乘积是这个元素的值。 **示例 1:** **输入:** nums = [2,3,-2,4] **输出:** `6` **解释:** 子数组 [2,3] 有最大乘积 6。 **示例 2:** **输入:** nums = [-2,0,-1] **输出:** 0 **解释:** 结果不能为 2, 因为 [-2,-1] 不是子数组。 **提示:** - `1 <= nums.length <= 2 * 104` - `-10 <= nums[i] <= 10` - `nums` 的任何子数组的乘积都 **保证** 是一个 **32-位** 整数
给你一个整数数组 `nums` 和一个整数 `k` ，请你统计并返回 _该数组中和为 `k` 的子数组的个数_ 。 子数组是数组中元素的连续非空序列。 **示例 1：** **输入：**nums = [1,1,1], k = 2 **输出：**2 **示例 2：** **输入：**nums = [1,2,3], k = 3 **输出：**2 **提示：** - `1 <= nums.length <= 2 * 104` - `-1000 <= nums[i] <= 1000` - `-107 <= k <= 107`
给你二叉树的根节点 `root` 和一个表示目标和的整数 `targetSum` 。判断该树中是否存在 **根节点到叶子节点** 的路径，这条路径上所有节点值相加等于目标和 `targetSum` 。如果存在，返回 `true` ；否则，返回 `false` 。 **叶子节点** 是指没有子节点的节点。 **示例 1：**  **输入：**root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22 **输出：**true **解释：**等于目标和的根节点到叶节点路径如上图所示。 **示例 2：**  **输入：**root = [1,2,3], targetSum = 5 **输出：**false **解释：**树中存在两条根节点到叶子节点的路径：
给你一棵二叉树的根节点 `root` ，翻转这棵二叉树，并返回其根节点。 **示例 1：**  **输入：**root = [4,2,7,1,3,6,9] **输出：**[4,7,2,9,6,3,1] **示例 2：**  **输入：**root = [2,1,3] **输出：**[2,3,1] **示例 3：** **输入：**root = [] **输出：**[] **提示：** - 树中节点数目范围在 `[0, 100]` 内 - `-100 <= Node.val <= 100`
给定一个含有 `n` 个正整数的数组和一个正整数 `target` **。** 找出该数组中满足其总和大于等于 `target` 的长度最小的 **子数组** `[numsl, numsl+1, ..., numsr-1, numsr]` ，并返回其长度**。**如果不存在符合条件的子数组，返回 `0` 。 **示例 1：** **输入：**target = 7, nums = [2,3,1,2,4,3] **输出：**2 **解释：**子数组 `[4,3]` 是该条件下的长度最小的子数组。 **示例 2：** **输入：**target = 4, nums = [1,4,4] **输出：**1 **示例 3：** **输入：**target = 11, nums = [1,1,1,1,1,1,1,1] **输出：**0 **提示：** - `1 <= target <= 109` - `1 <= nums.length <= 105` - `1 <= nums[i] <= 104` **进阶：** - 如果你已经实现 `O(n)` 时间复杂度的解法, 请尝试设
给你一个字符串表达式 `s` ，请你实现一个基本计算器来计算并返回它的值。 整数除法仅保留整数部分。 你可以假设给定的表达式总是有效的。所有中间结果将在 `[-2^31, 2^31 - 1]` 的范围内。 **注意：**不允许使用任何将字符串作为数学表达式计算的内置函数，比如 `eval()` 。 **示例 1：** **输入：**s = "3+2 x 2" **输出：**7 **示例 2：** **输入：**s = " 3/2 " **输出：**1 **示例 3：** **输入：**s = " 3+5 / 2 " **输出：**5 **提示：** - `1 <= s.length <= 3 * 105` - `s` 由整数和算符 `('+', '-', '*', '/')` 组成，中间由一些空格隔开 - `s` 表示一个 **有效表达式** - 表达式中的所有整数都是非负整数，且在范围 `[0, 231 - 1]` 内 - 题目数据保证答案是一个 **32-bit 整数**
给定一个大小为 `n` 的数组 `nums` ，返回其中的多数元素。多数元素是指在数组中出现次数 **大于** `⌊ n/2 ⌋` 的元素。 你可以假设数组是非空的，并且给定的数组总是存在多数元素。 **示例 1：** **输入：**nums = [3,2,3] **输出：**3 **示例 2：** **输入：**nums = [2,2,1,1,1,2,2] **输出：**2 **提示：** - `n == nums.length` - `1 <= n <= 5 * 104` - `-109 <= nums[i] <= 109` - 输入保证数组中一定有一个多数元素。 **进阶：**尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。 **示例 1：**  **输入：**head = [1,2,3,4] **输出：**[2,1,4,3] **示例 2：** **输入：**head = [] **输出：**[] **示例 3：** **输入：**head = [1] **输出：**[1] **提示：** - 链表中节点的数目在范围 `[0, 100]` 内 - `0 <= Node.val <= 100`
给你一个字符串 `s` 和一个字符串列表 `wordDict` 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 `s` 则返回 `true`。 **注意：**不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。 **示例 1：** **输入:** s = "leetcode", wordDict = ["leet", "code"] **输出:** true **解释:** 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。 **示例 2：** **输入:** s = "applepenapple", wordDict = ["apple", "pen"] **输出:** true **解释:** 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。 注意，你可以重复使用字典中的单词。 **示例 3：** **输入:** s = "catsandog", wordDict = ["cats", "dog", "sand", "and",
给定一个数组 `nums`，编写一个函数将所有 `0` 移动到数组的末尾，同时保持非零元素的相对顺序。 **请注意** ，必须在不复制数组的情况下原地对数组进行操作。 **示例 1:** **输入:** nums = `[0,1,0,3,12]` **输出:** `[1,3,12,0,0]` **示例 2:** **输入:** nums = `[0]` **输出:** `[0]` **提示**: - `1 <= nums.length <= 104` - `-231 <= nums[i] <= 231 - 1` **进阶：**你能尽量减少完成的操作次数吗？
给两个整数数组 `nums1` 和 `nums2` ，返回 _两个数组中 **公共的** 、长度最长的子数组的长度_ 。 **示例 1：** **输入：**nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7] **输出：**3 **解释：**长度最长的公共子数组是 [3,2,1] 。 **示例 2：** **输入：**nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0] **输出：**5 **提示：** - `1 <= nums1.length, nums2.length <= 1000` - `0 <= nums1[i], nums2[i] <= 100`