可惜我是水瓶座_

原创【LeetCode】随机链表的复制

新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 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]]

2024-07-16 22:24:24 104

原创【LeetCode】合并两个有序链表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。输入：l1 = [1,2,4], l2 = [1,3,4]一般这种链表题，为了解法统一，都会创建一个。输入：l1 = [], l2 = [0]两个链表的节点数目范围是 [0, 50]输入：l1 = [], l2 = []l1 和 l2 均按非递减顺序排列。输出：[1,1,2,3,4,4]

2024-07-16 22:10:04 198

原创【LeetCode】逆波兰表达式求值

tokens[i] 是一个算符（“+”、“-”、“*” 或 “/”），或是在范围 [-200, 200] 内的一个整数。输入：tokens = [“10”,“6”,“9”,“3”,“+”,“-11”,“该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * )。解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9。输入：tokens = [“4”,“13”,“5”,“/”,“+”]输入：tokens = [“2”,“1”,“+”,“3”,“*”]

2024-07-15 22:19:05 327

原创【LeetCode】最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。--> 返回 -3.minStack.getMin();--> 返回 -2.void push(int val) 将元素val推入堆栈。int getMin() 获取堆栈中的最小元素。也是用栈，记录数字的同时，记录目前所知道的最小值。void pop() 删除堆栈顶部的元素。int top() 获取堆栈顶部的元素。MinStack() 初始化堆栈对象。

2024-07-14 15:50:29 248

原创【LeetCode】有效的括号

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。使用栈来来存储，遇到右括号就去栈中寻找对应的左括号，找到了就。每个右括号都有一个对应的相同类型的左括号。s 仅由括号 ‘()[]{}’ 组成。左括号必须用相同类型的右括号闭合。输入：s = “()[]{}”左括号必须以正确的顺序闭合。输入：s = “()”输入：s = “(]”

2024-07-14 15:40:56 213

原创【LeetCode】简化路径

任意多个连续的斜杠（即，‘//’）都被视为单个斜杠 ‘/’。想象一个树形的文件目录，是二维的，有宽度有高度，但是因为每个时间点，我们只能处在一个点上，所以我们用一维的数据结构栈，来存储我们到达了哪一层就好了。给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格绝对路径（以 ‘/’ 开头），请你将其转化为更加简洁的规范路径。path 由英文字母，数字，‘.’，‘/’ 或 ‘_’ 组成。输入：path = “/a/./b/…输入：path = “/home//foo/”

2024-07-14 15:21:25 275

原创【LeetCode】用最少数量的箭引爆气球

墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。输入：points = [[10,16],[2,8],[1,6],[7,12]]输入：points = [[1,2],[3,4],[5,6],[7,8]]输入：points = [[1,2],[2,3],[3,4],[4,5]]-在x = 11处发射箭，击破气球[10,16]和[7,12]。-在x = 6处射出箭，击破气球[2,8]和[1,6]。

2024-07-14 14:41:31 251

原创【LeetCode】插入区间

给你一个无重叠的，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。输出：[[1,2],[3,10],[12,16]]

2024-07-14 13:52:02 283 1

原创【LeetCode】最长连续序列

给定一个未排序的整数数组 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-07-11 22:06:15 263

原创【LeetCode】存在重复元素 II

给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k。否则，返回 false。既然限制了abs(i - j) <= k，那么，首先想到的应该是滑动窗口，来限制数的范围，然后使用哈希表来，检查是否有相同的元素出现。输入：nums = [1,2,3,1,2,3], k = 2。输入：nums = [1,2,3,1], k = 3。输入：nums = [1,0,1,1], k = 1。

2024-07-11 21:43:40 372

原创【LeetCode】快乐数

然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果 n 是快乐数就返回 true；不是，则返回 false。对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。如果这个过程结果为 1，那么这个数就是快乐数。编写一个算法来判断一个数 n 是不是快乐数。简单粗暴的解法，模拟，将出现过的数字放入。中，如果遇到重复的了，就直接返回。

2024-07-11 21:25:20 276

原创【LeetCode】两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1]。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。输入：nums = [2,7,11,15], target = 9。输入：nums = [3,2,4], target = 6。输入：nums = [3,3], target = 6。

2024-07-11 21:11:16 248

原创【LeetCode】字母异位词分组

输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]给你一个字符串数组，请你将字母异位词组合在一起。可以按任意顺序返回结果列表。可以将每个单词，排一下序，然后相同排序的单词放到一起，最后，将每个。字母异位词是由重新排列源单词的所有字母得到的一个新单词。输入: strs = [“a”]输入: strs = [“”]输出: [[“a”]]输出: [[“”]]

2024-07-10 21:56:25 298

原创【LeetCode】单词规律

这里的遵循指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。输入: pattern = “abba”, s = “dog cat cat dog”输入:pattern = “abba”, s = “dog cat cat fish”输入: pattern = “aaaa”, s = “dog cat cat dog”给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。s 只包含小写英文字母和 ’ ’

2024-07-10 21:53:32 334

原创订单到期关闭

实习期间在做订单模块。遇到过订单到时关闭的场景。因为我们在通过回调接收第三方订单状态的时候，使用了rocketmq，在遇到订单超时关闭的场景的时候，为了不引入额外的依赖，我们就继续使用rocketmq的延迟队列来做实现。同时记录几种刚了解到的订单到期关闭实现方式。

2024-07-10 18:22:16 135

原创【LeetCode】赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。输入：ransomNote = “aa”, magazine = “aab”输入：ransomNote = “aa”, magazine = “ab”输入：ransomNote = “a”, magazine = “b”如果可以，返回 true；否则返回 false。利用哈希表，同时遍历两个字符串，记录字母出现的次数【遍历完了，而且字母对应的位置大于等于。

2024-07-09 20:03:31 204

原创【LeetCode】生命游戏

下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。输入：board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]输出：[[0,0,0],[1,0,1],[0,1,1],[0,1,0]]如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；如果死细胞周围正好有三个活细胞，则该位置死细胞复活；

2024-07-09 19:50:32 426

原创【LeetCode】螺旋矩阵

给你一个 m 行 n 列的矩阵 matrix ，请按照顺时针螺旋顺序，返回矩阵中的所有元素。输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]但是要注意各种变量，什么时候加，什么时候减，最好拿笔画一下，不然容易搞乱。输出：[1,2,3,4,8,12,11,10,9,5,6,7]输出：[1,2,3,6,9,8,7,4,5]就模拟就好了，顺时针模拟。

2024-07-07 21:41:34 273

原创【LeetCode】有效的数独

解释：除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与示例1 相同。请你判断一个 9 x 9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。board[i][j] 是一位数字（1-9）或者 ‘.’只需要根据以上规则，验证已经填入的数字是否有效即可。一个有效的数独（部分已被填充）不一定是可解的。数字 1-9 在每一行只能出现一次。数字 1-9 在每一列只能出现一次。输入：board =

2024-07-07 21:18:43 557

原创【LeetCode】全排列

输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]给定一个不含重复数字的数组 nums ，返回其所有可能的全排列。你可以按任意顺序返回答案。深度优先遍历，针对结果的每个位置，都进行一次遍历，使用。输入：nums = [1,2,3]输出：[[0,1],[1,0]]nums 中的所有整数互不相同。输入：nums = [0,1]数组来记录，此位置是否使用过。输入：nums = [1]

2024-07-04 20:57:04 268

原创【LeetCode】三数之和

给你一个整数数组 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-07-03 18:50:42 268

原创【LeetCode】盛最多水的容器

给定一个长度为 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-07-03 18:38:37 159

原创【Java集合类】ArrayList

ArrayList学习

2024-07-03 09:51:55 575

原创【LeetCode】两数之和 II - 输入有序数组

如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length。以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。因此 index1 = 1, index2 = 2。返回 [1, 2]。因此 index1 = 1, index2 = 2。输入：numbers = [2,7,11,15], target = 9。

2024-07-02 21:58:31 476

原创【LeetCode】验证回文串

如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。给你一个字符串 s，如果它是回文串，返回 true；输入: s = “A man, a plan, a canal: Panama”解释：“amanaplanacanalpanama” 是回文串。解释：在移除非字母数字字符之后，s 是一个空字符串 “”。由于空字符串正着反着读都一样，所以是回文串。解释：“raceacar” 不是回文串。输入：s = “race a car”输入：s = " "

2024-07-02 21:52:38 353

原创【LeetCode】Z 字形变换

之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“PAHNAPLSIIGYIR”。将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。输入：s = “PAYPALISHIRING”, numRows = 3。输入：s = “PAYPALISHIRING”, numRows = 4。输入：s = “A”, numRows = 1。输出：“PAHNAPLSIIGYIR”输出：“PINALSIGYAHRPI”因为这个Z字形上上下下，触底反弹。

2024-07-01 19:57:35 279

原创【LeetCode】反转字符串中的单词

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。进阶：如果字符串在你使用的编程语言中是一种可变数据类型，请尝试使用 O(1) 额外空间复杂度的原地解法。s 中使用至少一个空格将字符串中的单词分隔开。解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。给你一个字符串 s ，请你反转字符串中单词的顺序。解释：反转后的字符串中不能存在前导空格和尾随空格。

2024-07-01 19:30:58 835

原创【LeetCode】罗马数字转整数

数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4。每次先往后看两个，看看是不是属于那6个特例中的，如果属于，就算上，然后跳一格，继续向后，否则就挨个算就好了。s 仅含字符 (‘I’, ‘V’, ‘X’, ‘L’, ‘C’, ‘D’, ‘M’)X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

2024-06-29 15:32:35 324

原创【LeetCode】分发糖果

利用left和right数组，来存储每一侧至少应该放多少个糖果，刚开始每个小孩先分一个，然后少的再补。假想一个最终的糖果数组，我们如何检查呢，可以先统一检查左侧，再统一检查右侧。解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。根据题目要求，两个数相邻，若不想等，那么比较大的那个数分得的糖果更多。请你给每个孩子分发糖果，计算并返回需要准备的最少糖果数目。第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。

2024-06-28 20:27:25 340

原创【LeetCode】接雨水

解释：上面是由数组 [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-06-28 19:28:21 584

原创【LeetCode】加油站

从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。输入: gas = [1,2,3,4,5], cost = [3,4,5,1,2]开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油。开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油。开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油。

2024-06-27 20:15:49 355

原创【LeetCode】O(1) 时间插入、删除和获取随机元素

int getRandom() 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。bool insert(int val) 当元素 val 不存在时，向集合中插入该项，并返回 true；bool remove(int val) 当元素 val 存在时，从集合中移除该项，并返回 true；// 由于 2 是集合中唯一的数字，getRandom 总是返回 2。集合现在包含 [2]。// 返回 false ，表示集合中不存在 2。// 2 已在集合中，所以返回 false。

2024-06-27 09:58:28 826

原创【LeetCode】LRU缓存

用双向链表，为什么是双向的呢，因为lru更新的时候，我们要把它插入到最新的位置，所以在只知道一个位置的时候，双向链表插入的时候，可以做到。int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1。// 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}// 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}// 缓存是 {1=1, 2=2}// 返回 -1 (未找到)// 返回 -1 (未找到)lRUCache.put(1, 1);

2024-06-26 18:56:29 439

原创【LeetCode】多数元素

每每遍历到一个元素，看一下支不支持自己，支持的话，票数+1，不支持票数-1，投完票之后看看当前投票的对象的票数，如果票数为0了，那么说明暂时没人支持他了，自己就上。因为多数元素出现次数大于 ⌊ n/2 ⌋，所以可以使用投票的方法，因为支持自己的元素个数多于一半了，所以可以保证自己一定胜出。给定一个大小为 n 的数组 nums ，返回其中的多数元素。先假定一个元素是多数元素，然后自己支持自己，次数为1，然后继续往后面遍历就行了。输入：nums = [2,2,1,1,1,2,2]

2024-06-25 21:52:00 306

原创【LeetCode】H 指数

根据维基百科上 h 指数的定义：h 代表“高引用次数” ，一名科研人员的 h 指数是指他（她）至少发表了 h 篇论文，并且至少有 h 篇论文被引用次数大于等于 h。由于研究者有 3 篇论文每篇至少被引用了 3 次，其余两篇论文每篇被引用不多于 3 次，所以她的 h 指数是 3。解释：给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5 次。下图，每一个大框内，右边一列是大于它的数的个数，左边一列是当前被引用的数量。，先对它进行排序，得到。

2024-06-25 21:31:56 304

原创【LeetCode】跳跃游戏

遍历所有位置，每每到一个位置，就判断当前位置是否真的可以到达，如果可以到达，然后看目前为止可以到达的最远距离。给你一个非负整数数组 nums ，你最初位于数组的第一个下标。解释：无论怎样，总会到达下标为 3 的位置。解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。判断你是否能够到达最后一个下标，如果可以，返回 true；否则，返回 false。输入：nums = [2,3,1,1,4]输入：nums = [3,2,1,0,4]

2024-06-24 23:00:51 316

原创【LeetCode】寻找旋转排序数组中的最小值

注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次的结果为数组 [a[n-1], a[0], a[1], a[2], …解释：原数组为 [0,1,2,4,5,6,7] ，旋转 3 次得到输入数组。解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]输入：nums = [4,5,6,7,0,1,2]输入：nums = [3,4,5,1,2]

2024-06-18 20:19:27 253

原创【LeetCode】在排序数组中查找元素的第一个和最后一个位置

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。输入：nums = [5,7,7,8,8,10], target = 8。输入：nums = [5,7,7,8,8,10], target = 6。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。如果数组中不存在目标值 target，返回 [-1, -1]。输入：nums = [], target = 0。的元素，并且找到的结果的下标。输出：[-1,-1]输出：[-1,-1]使用二分找到第一个为。

2024-06-17 14:04:35 176

原创【LeetCode】搜索二维矩阵

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13。输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3。给你一个整数 target ，如果 target 在矩阵中，返回 true；否则，返回 false。因为数组是二位的，所以我们需要将得到的下标索引进行。每行中的整数从左到右按非严格递增顺序排列。每行的第一个整数大于前一行的最后一个整数。

2024-06-15 12:03:32 132

原创【LeetCode】数据流的中位数

double findMedian() 返回到目前为止所有元素的中位数。由于问题是要求中位数，也就是说我们可以快速的找到中位数【奇数情况】或者中位数两边【偶数情况】的数字就好了。// 返回 1.5 ((1 + 2) / 2)如果列表的大小是偶数，则没有中间值，中位数是两个中间值的平均值。void addNum(int num) 将数据流中的整数 num 添加到数据结构中。例如 arr = [2,3] 的中位数是 (2 + 3) / 2 = 2.5。例如 arr = [2,3,4] 的中位数是 3。

2024-06-14 15:20:16 410

空空如也

空空如也