qq_43623492的博客

题目：给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外，这两个数都不会以 0 开头。示例2：输入：l1 = [0], l2 = [0]输出：[0]示例3：输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]输出：[8,9,9,9,0,0,0,1]提示：每个链表中的节点数在范围 [1, 100]

题目：这里是引用给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。示例1：输入：nums = [1,2,2]输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]示例2：输入：nums = [0]输出：[[],[0]]提示：1 <= nums.length <= 10-10 <= nums[i] <= 10解题代码：

题目：给你一个整数数组 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] <= 10nums 中的所有

题目：给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。你可以按 任何顺序 返回答案。示例1：输入：n = 4, k = 2输出：[[2,4],[3,4],[2,3],[1,2],[1,3],[1,4],]示例2：输入：n = 1, k = 1输出：[[1]]提示：1 <= n <= 201 <= k <= n解题代码：class Solution { public List<Lis

题目：编写一个程序，通过填充空格来解决数独问题。数独的解法需 遵循如下规则：数字 1-9 在每一行只能出现一次。数字 1-9 在每一列只能出现一次。数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）数独部分空格内已填入了数字，空白格用 ‘.’ 表示。提示：board.length == 9board[i].length == 9board[i][j] 是一位数字或者 ‘.’题目数据 保证 输入数独仅有一个解解题代码：class Solutio

题目：请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。数字 1-9 在每一行只能出现一次。数字 1-9 在每一列只能出现一次。数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）注意：一个有效的数独（部分已被填充）不一定是可解的。只需要根据以上规则，验证已经填入的数字是否有效即可。空白格用 ‘.’ 表示。示例1：示例2：提示：board.length == 9board[i].length ==

题目：给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。你可以假设除了整数 0 之外，这个整数不会以零开头。示例1：输入：digits = [1,2,3]输出：[1,2,4]解释：输入数组表示数字 123。示例2：输入：digits = [4,3,2,1]输出：[4,3,2,2]解释：输入数组表示数字 4321。示例3：输入：digits = [0]输出：[1]提示：1 &l

题目：给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的每个数字在每个组合中只能使用 一次 。注意：解集不能包含重复的组合。示例1：输入: candidates = [10,1,2,7,6,1,5], target = 8,输出:[[1,1,6],[1,2,5],[1,7],[2,6]]示例2：输入: candidates = [2,5,2,1,

题目：给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。对于给定的输入，保证和为 target 的不同组合数少于 150 个。示例1：输入：candidates = [2,3,6,7], target

题目：给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。示例1：输入：nums = [1,1,2]输出：[[1,1,2],[1,2,1],[2,1,1]]示例2：输入：nums = [1,2,3]输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]提示：1 <= nums.length <= 8-10 <= nums[i] <= 10解题代码：// 比上一题（

题目：给定一个不含重复数字的数组 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] &

题目：罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：I 可以放在

题目：罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。字符 数值I 1V 5X 10L 50C 100D 500M 1000例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II

题目：根据一棵树的中序遍历与后序遍历构造二叉树。注意:你可以假设树中没有重复的元素。示例1：中序遍历 inorder = [9,3,15,20,7]后序遍历 postorder = [9,15,7,20,3]解题代码：struct TreeNode* buildATree(int* postorder, int* inorder, int len){ if(len == 0) return NULL; // 每次选中后序遍历数组中的最后一个数据作为根

题目：根据一棵树的中序遍历与后序遍历构造二叉树。注意:你可以假设树中没有重复的元素。示例1:Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]Output: [3,9,20,null,null,15,7]示例2：Input: preorder = [-1], inorder = [-1]Output: [-1]提示：1 <= preorder.length <= 3000inorder.lengt

题目：给定一个已按照 非递减顺序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。示例1：输入：numbers = [2,7,11,1

题目：给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个下标。示例1：输入：nums = [2,3,1,1,4]输出：true解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。示例2：输入：nums = [3,2,1,0,4]输出：false解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最

题目：给你一个非负整数数组 nums ，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。你的目标是使用最少的跳跃次数到达数组的最后一个位置。假设你总是可以到达数组的最后一个位置。示例1：输入: nums = [2,3,1,1,4]输出: 2解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。示例2：输入: nums = [2,3,0,1,4]输出: 2提示：

题目：给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。说明：本题中，我们将空字符串定义为有效的回文串。示例1：输入: “A man, a plan, a canal: Panama”输出: true解释：“amanaplanacanalpanama” 是回文串示例2：输入: “race a car”输出: false解释：“raceacar” 不是回文串提示：111 <= s.length <= 2∗1052 * 10^52∗

题目：给定一个二叉树struct Node { int val; Node *left; Node *right; Node *next; }填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。示例：输入：root = [1,2,3,4,5,null,7]输出：[1,#,2,3,#,4,5,7,#]解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 ne

题目：给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：struct Node { int val; Node *left; Node *right; Node *next;}填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。示例：输入：root = [1,2,3,4,5,6,7]输出：[1,#,

题目：给你一个 无重叠的 ，按照区间起始端点排序的区间列表。这里是引用在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。示例1：输入：intervals = [[1,3],[6,9]], newInterval = [2,5]输出：[[1,5],[6,9]]示例2：输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]输出：[[1,2],[3,10

题目：给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例1：输入：root = [2,1,3]输出：true示例2：输入：root = [5,1,4,null,null,3,6]输出：false解释：根节点的值是 5 ，但是右子节点的值是 4 。提示：树中节点数目范围在[1, 104] 内-

题目：给定一个二叉树的根节点 root ，返回它的 中序 遍历。示例1：输入：root = [1,null,2,3]输出：[1,3,2]示例2：输入：root = []输出：[]示例3：输入：root = [1]输出：[1]示例4：输入：root = [1,2]输出：[2,1]示例5：输入：root = [1,null,2]输出：[1,2]解题代码：class Solution { public static void inorde

题目：给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。你应当 保留 两个分区中每个节点的初始相对位置。示例1：输入：head = [1,4,3,2,5,2], x = 3输出：[1,2,2,4,3,5]示例2：输入：head = [2,1], x = 2输出：[1,2]提示：链表中节点的数目在范围 [0, 200] 内-100 <= Node.val <= 100-20

题目：给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。示例1：输入：head = [1,2,3,4,5], k = 2输出：[4,5,1,2,3]示例2：输入：head = [0,1,2], k = 4输出：[2,0,1]提示：链表中节点的数目在范围 [0, 500] 内-100 <= Node.val <= 1000 <= k <= 2 * 109解题代码：struct ListNode* rotateR

题目：存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素 只出现一次 。返回同样按升序排列的结果链表。示例1：输入：head = [1,1,2]输出：[1,2]示例2：输入：head = [1,1,2,3,3]输出：[1,2,3]提示：链表中节点数目在范围 [0, 300] 内-100 <= Node.val <= 100题目数据保证链表已经按升序排列解题代码：struct ListNode* delet

题目：给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。示例：输入：nums = [2,0,2,1,1,0]输出：[0,0,1,1,2,2]示例2：输入：nums = [2,0,1]输出：[0,1,2]示例3：输入：nums = [0]输出：[0]示例4：输入：nums = [1]输出：[1]提示：n == n

题目：给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。进阶：你可以设计一个只使用常数额外空间的算法来解决此问题吗？你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。示例1：输入：head = [1,2,3,4,5], k = 2输出：[2,1,4,3,5]示例2：输入：head = [1,2,3,4,5], k = 3输出：[3,2

题目：给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。示例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 = []输出

题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。示例1：输入：head = [1,2,3,4,5]输出：[5,4,3,2,1]示例2：输入：head = [1,2]输出：[2,1]示例3：输入：head = []输出：[]提示：链表中节点的数目范围是 [0, 5000]-5000 <= Node.val <= 5000解题代码：/** * Definition for singly-linked list. * s

题目：给你一个非负整数 x ，计算并返回 x 的 算术平方根 。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。示例1：输入：x = 4输出：2示例2：输入：x = 8输出：2解释：8 的算术平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。提示：0<=x<=231−10 <= x <= 2^{31} - 10&lt

题目：以数组 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]

题目：给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。示例1：输入：nums = [1,2,0]输出：3示例2：输入：nums = [3,4,-1,1]输出：2示例3：输入：nums = [7,8,9,11,12]输出：1提示：1<=nums.length<=5∗1051 <= nums.length <= 5 * 10^51<=nums.

题目：给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为 O(log n) 的算法。示例1：输入: nums = [1,3,5,6], target = 5输出: 2示例2：输入: nums = [1,3,5,6], target = 2输出: 1示例3：输入: nums = [1,3,5,6], target = 7输出: 4示例4：输入: nums = [1,3,5,6

题目：给定一个按照升序排列的整数数组 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：输入：nu

题目：实现 strStr() 函数。给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。说明：当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。示例1：输入：haystack

题目：给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。说明：为什么返回数值是整数，但输出的答案是数组呢?请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。你可以想象内部操作如下:// nums 是以“引用”方式传递的。也就是说，不对实参作任何

题目：给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。说明：为什么返回数值是整数，但输出的答案是数组呢?请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。你可以想象内部操作如下:// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝int len = removeDuplic

题目：给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。示例1：输入：head = [1,2,3,4]输出：[2,1,4,3]示例2：输入：head = []输出：[]示例3：输入：head = [1]输出：[1]提示：链表中节点的数目在范围 [0, 100] 内0 <= Node.val <= 100解题代码：/** * Definition for sing