远山凛凛-CSDN博客

原创力扣23 合并k个升序链表 Java版本

输入：lists = [[1,4,5],[1,3,4],[2,6]]请你将所有链表合并到一个升序链表中，返回合并后的链表。lists[i].length 的总和不超过 10^4。给你一个链表数组，每个链表都已经按升序排列。输出：[1,1,2,3,4,4,5,6]将它们合并到一个有序链表中得到。lists[i] 按升序排列。输入：lists = [[]]输入：lists = []

2024-09-29 16:02:08 442

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

2024-09-29 15:04:03 293

原创力扣148 排序链表 Java版本

进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？给你链表的头结点 head ，请将其按升序排列并返回排序后的链表。链表中节点的数目在范围 [0, 5 * 104] 内。输入：head = [-1,5,3,4,0]输入：head = [4,2,1,3]输出：[-1,0,3,4,5]输出：[1,2,3,4]输入：head = []

2024-09-26 20:30:08 473

原创力扣138 随机链表的复制 Java版本

新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]输入：head = [[3,null],[3,0],[3,null]]输出：[[3,null],[3,0],[3,null]]输入：head = [[1,1],[2,1]]输出：[[1,1],[2,1]]

2024-09-26 15:29:22 398

原创力扣24 两两交换链表中的节点 Java版本

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

2024-09-25 15:23:31 319

原创力扣19 删除链表的倒数第N个节点 Java版本

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。输入：head = [1,2,3,4,5], n = 2。输入：head = [1,2], n = 1。输入：head = [1], n = 1。进阶：你能尝试使用一趟扫描实现吗？输出：[1,2,3,5]链表中结点的数目为 sz。

2024-09-25 14:46:12 319

原创力扣2 两数相加 Java版本

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]你可以假设除了数字 0 之外，这两个数都不会以 0 开头。输入：l1 = [2,4,3], l2 = [5,6,4]每个链表中的节点数在范围 [1, 100] 内。输入：l1 = [0], l2 = [0]输出：[8,9,9,9,0,0,0,1]题目数据保证列表表示的数字不含前导零。输出：[7,0,8]

2024-09-25 14:32:05 188

原创力扣234 回文链表 Java版本

进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？给你一个单链表的头节点 head ，请你判断该链表是否为。如果是，返回 true；否则，返回 false。链表中节点数目在范围[1, 105] 内。输入：head = [1,2,2,1]输入：head = [1,2]

2024-09-24 18:52:24 387

原创力扣240 搜索二维矩阵Ⅱ Java版本

输入：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 = 20。输入：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。每列的所有元素从上到下升序排列。每行的元素从左到右升序排列。每列的元素从上到下升序排列。

2024-09-24 16:00:07 339

原创力扣48 旋转图像 Java版本

输入：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],[12,6,8,9],[16,7,10,11]]你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]输出：[[7,4,1],[8,5,2],[9,6,3]]

2024-09-24 15:39:55 627

原创力扣73 矩阵置零 Java版本

请使用原地算法。输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]一个简单的改进方案是使用 O(m + n) 的额外空间，但这仍然不是最好的解决方案。一个直观的解决方案是使用 O(mn) 的额外空间，但这并不是一个好的解决方案。输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]输出：[[1,0,1],[0,0,0],[1,0,1]]你能想出一个仅使用常量空间的解决方案吗？

2024-09-23 20:50:41 179

原创力扣41 缺失的第一个正数 Java版本

给你一个整数数组 nums，返回数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。题目数据保证数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位整数范围内。保证数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位整数范围内。输入: nums = [-1,1,0,-3,3]输入: nums = [1,2,3,4]输出: [24,12,8,6]输出: [0,0,9,0,0]

2024-09-23 15:12:17 430

原创力扣76 最小覆盖子串 Java版本

返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “”。解释：最小覆盖子串 “BANC” 包含来自字符串 t 的 ‘A’、‘B’ 和 ‘C’。对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。输入：s = “ADOBECODEBANC”, t = “ABC”解释: t 中两个字符 ‘a’ 均应包含在 s 的子串中，输入: s = “a”, t = “aa”输入：s = “a”, t = “a”s 和 t 由英文字母组成。

2024-09-23 13:00:10 816

原创力扣189 轮转数组 Java版本

输入: nums = [1,2,3,4,5,6,7], k = 3。输入：nums = [-1,-100,3,99], k = 2。向右轮转 1 步: [7,1,2,3,4,5,6]向右轮转 2 步: [6,7,1,2,3,4,5]向右轮转 3 步: [5,6,7,1,2,3,4]向右轮转 1 步: [99,-1,-100,3]向右轮转 2 步: [3,99,-1,-100]输出: [5,6,7,1,2,3,4]输出：[3,99,-1,-100]

2024-09-21 11:09:51 337

原创力扣239 滑动窗口最大值 Java版本

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。输入：nums = [1,3,-1,-3,5,3,6,7], k = 3。滑动窗口的位置最大值。输入：nums = [1], k = 1。输出：[3,3,5,5,6,7]返回滑动窗口中的最大值。

2024-09-20 13:22:21 231

原创力扣560 和为k的子数组 Java版本

给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的子数组的个数。输入：nums = [1,1,1], k = 2。输入：nums = [1,2,3], k = 3。子数组是数组中元素的连续非空序列。

2024-09-20 11:00:20 328

原创力扣438 找到字符串中所有字母异位词 Java版本

给定两个字符串 s 和 p，找到 s 中所有 p 的异位词的子串，返回这些子串的起始索引。起始索引等于 0 的子串是 “cba”, 它是 “abc” 的异位词。起始索引等于 6 的子串是 “bac”, 它是 “abc” 的异位词。起始索引等于 0 的子串是 “ab”, 它是 “ab” 的异位词。起始索引等于 1 的子串是 “ba”, 它是 “ab” 的异位词。起始索引等于 2 的子串是 “ab”, 它是 “ab” 的异位词。输入: s = “abab”, p = “ab”输出: [0,1,2]

2024-09-19 20:58:12 644

原创力扣3 无重复字符的最长子串 Java版本

给定一个字符串 s ，请你找出其中不含有重复字符的最长子串的长度。示例 1:输入: s = “abcabcbb”输出: 3解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。示例 2:输入: s = “bbbbb”输出: 1解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。示例 3:输入: s = “pwwkew”输出: 3解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。请注意，你的答案必须是子串的长度，“pwke” 是一个子序列，不是

2024-09-19 20:28:45 205

原创力扣42 接雨水 Java版本

解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]输入：height = [4,2,0,3,2,5]

2024-09-19 19:20:10 519

原创力扣15 三数之和 Java版本

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i!= k ，同时还满足 nums[i] + nums[j] + nums[k] == 0。不同的三元组是 [-1,0,1] 和 [-1,-1,2]。输入：nums = [-1,0,1,2,-1,-4]输出：[[-1,-1,2],[-1,0,1]]输入：nums = [0,1,1]输入：nums = [0,0,0]解释：唯一可能的三元组和为 0。输出：[[0,0,0]]

2024-09-12 15:50:32 216

原创力扣238 移动零 Java版本时间复杂度为O(0)

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。请注意，必须在不复制数组的情况下原地对数组进行操作。输入: nums = [0,1,0,3,12]进阶：你能尽量减少完成的操作次数吗？输出: [1,3,12,0,0]输入: nums = [0]

2024-09-12 14:54:00 327

原创力扣11 盛最多水的容器 Java版本

给定一个长度为 n 的整数数组 height。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i])。解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。输入：[1,8,6,2,5,4,8,3,7]输入：height = [1,1]返回容器可以储存的最大水量。说明：你不能倾斜容器。

2024-09-12 14:53:29 241

原创力扣128 最长连续序列 Java版本

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。解释：最长数字连续序列是 [1, 2, 3, 4]。输入：nums = [0,3,7,2,5,8,4,6,0,1]请你设计并实现时间复杂度为 O(n) 的算法解决此问题。输入：nums = [100,4,200,1,3,2]

2024-09-11 21:13:19 126

原创 new String()，toString()和Arrays.toString()的区别

从结果中可以看出，如果直接调用toString()会是输出的[class name]@[hashCode]new String()就会通过构造函数生成一个String字符串。下面写了一段代码来展示结果。

2024-09-11 20:25:52 196

原创力扣49 字母异位词分组 Java版本

输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]字母异位词是由重新排列源单词的所有字母得到的一个新单词。输入: strs = [“a”]输入: strs = [“”]输出: [[“a”]]输出: [[“”]]

2024-09-11 20:13:50 578

原创 Driver com.mysql.cj.jdbc.Driver claims to not accept jdbcUrl, jdbc:mysql:aws://localhost:3306

然后把这个url中的aws:去掉就能够正常运行了，希望能够帮到和我一样错误的同学。下面图片中的url中赋复制的，就会出现报错。这个报错的url我是从下面这里复制的。

2024-09-10 16:29:00 321

原创力扣122 买卖股票的最佳时机 Ⅱ Java版本

解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。输入：prices = [7,1,5,3,6,4]返回你能获得的最大利润。

2024-08-05 16:41:50 201 1

原创力扣121 买卖股票的最佳时机 Java版本

解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；解释：在这种情况下, 没有交易完成, 所以最大利润为 0。输入：prices = [7,6,4,3,1]输入：[7,1,5,3,6,4]

2024-08-05 16:41:24 396

原创力扣337 打家劫舍Ⅲ Java版本

除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。返回在不触动警报的情况下，小偷能够盗取的最高金额。小偷又发现了一个新的可行窃的地区。输入: root = [3,2,3,null,3,null,1]解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7。输入: root = [3,4,5,1,3,null,1]解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9。树的节点数在 [1, 104] 范围内。

2024-07-12 17:21:10 514

原创力扣213 打家劫舍 Ⅱ Java版本

同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，今晚能够偷窃到的最高金额。解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。输入：nums = [1,2,3,1]输入：nums = [2,3,2]输入：nums = [1,2,3]

2024-07-12 17:20:55 248

原创力扣139 单词拆分 Java版本

输入: s = “catsandog”, wordDict = [“cats”, “dog”, “sand”, “and”, “cat”]解释: 返回 true 因为 “applepenapple” 可以由 “apple” “pen” “apple” 拼接成。输入: s = “applepenapple”, wordDict = [“apple”, “pen”]输入: s = “leetcode”, wordDict = [“leet”, “code”]注意，你可以重复使用字典中的单词。

2024-07-05 16:44:21 260

原创力扣198 打家劫舍 Java版本

每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下，一夜之内能够偷窃到的最高金额。解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。输入：[2,7,9,3,1]输入：[1,2,3,1]

2024-07-05 16:44:07 415

原创力扣322 零钱兑换 Java版本

计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。输入：coins = [1, 2, 5], amount = 11。输入：coins = [2], amount = 3。输入：coins = [1], amount = 0。你可以认为每种硬币的数量是无限的。解释：11 = 5 + 5 + 1。

2024-06-27 16:45:41 208

原创力扣279 完全平方数 Java版本

完全平方数是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。给你一个整数 n ，返回和为 n 的完全平方数的最少数量。解释：12 = 4 + 4 + 4。解释：13 = 4 + 9。

2024-06-27 16:45:21 384

原创力扣518 零钱兑换Ⅱ Java版本

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0。输入：amount = 5, coins = [1, 2, 5]输入：amount = 10, coins = [10]输入：amount = 3, coins = [2]解释：只用面额 2 的硬币不能凑成总金额 3。题目数据保证结果符合 32 位带符号整数。coins 中的所有值互不相同。假设每一种面额的硬币有无限个。

2024-06-26 16:08:12 252

原创力扣377 组合总和Ⅳ Java版本

给你一个由不同整数组成的数组 nums ，和一个目标整数 target。请你从 nums 中找出并返回总和为 target 的元素组合的个数。进阶：如果给定的数组中含有负数会发生什么？问题会产生何种变化？如果允许负数出现，需要向题目中添加哪些限制条件？输入：nums = [1,2,3], target = 4。输入：nums = [9], target = 3。题目数据保证答案符合 32 位整数范围。请注意，顺序不同的序列被视作不同的组合。nums 中的所有元素互不相同。

2024-06-26 16:07:34 511

原创力扣474 一和零 Java版本

其他满足题意但较小的子集包括 {“0001”,“1”} 和 {“10”,“1”,“0”}。解释：最多有 5 个 0 和 3 个 1 的最大子集是 {“10”,“0001”,“1”,“0”} ，因此答案是 4。输入：strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3。输入：strs = [“10”, “0”, “1”], m = 1, n = 1。解释：最大的子集是 {“0”, “1”} ，所以答案是 2。

2024-06-25 15:16:46 392

原创力扣494 目标和 Java版本

例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1”。返回可以通过上述方法构造的、运算结果等于 target 的不同表达式的数目。输入：nums = [1,1,1,1,1], target = 3。给你一个非负整数数组 nums 和一个整数 target。输入：nums = [1], target = 1。解释：一共有 5 种方法让最终目标和为 3。

2024-06-25 15:15:20 441

原创力扣1049 最后一块石头的重量Ⅱ Java版本

可以用0-1背包的思路来解决这个问题，当背包中所能装的石头的重量越接近所有重量的一半的时候，最后一块石头所剩的重量就越小。= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，输入：stones = [31,26,33,21,40]输入：stones = [2,7,4,1,8,1]

2024-06-14 10:45:41 311

原创力扣416 分割等和子集 Java版本

然后就可以考虑用0-1背包的思路来解决这个问题，这里元素的值就是当前元素的价值和重量，背包的容量就是子集元素和的一半，最终需要确定这个背包里是否能够正好装进价值为子集和一半的时候。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。找出两个子集，让这两个子集的和相等可以转化思路为：找到一个子集，这个子集的和是子集中所有元素和的一半。解释：数组可以分割成 [1, 5, 5] 和 [11]。输入：nums = [1,5,11,5]输入：nums = [1,2,3,5]

2024-06-14 09:55:36 535 1

空空如也

空空如也