可惜我是水瓶座_

原创【LeetCode】将有序数组转换为二叉搜索树

因为数组严格递增，所以每次将中点拿出来，变成一个节点，然后再递归的往左右两边探寻。给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵。解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。输入：nums = [-10,-3,0,5,9]输出：[0,-3,9,-10,null,5]nums 按严格递增顺序排列。输入：nums = [1,3]

2024-08-08 21:43:28 377

原创【LeetCode】组合

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。回溯，先固定一个位置，然后遍历后续的所有位置，然后再回退。你可以按任何顺序返回答案。输入：n = 4, k = 2。输入：n = 1, k = 1。

2024-08-08 21:33:03 210 1

输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCCED”输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCB”输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “SEE”

2024-08-07 21:09:27 363

原创【LeetCode】括号生成

回溯，优先放置左括号，两个边界条件，一个是正常的，即左右都放完了，还有一个是异常的，也就是左边剩余的比右边多，直接。输出：[“((()))”,“(()())”,“(())()”,“()(())”,“()()()”]数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。

2024-08-07 20:59:54 157

原创【LeetCode】最小基因变化

输入：start = “AACCGGTT”, end = “AAACGGTA”, bank = [“AACCGGTA”,“AACCGCTA”,“AAACGGTA”]输入：start = “AAAAACCC”, end = “AACCCCCC”, bank = [“AAAACCCC”,“AAACCCCC”,“AACCCCCC”]一次基因变化就意味着这个基因序列中的一个字符发生了变化。输入：start = “AACCGGTT”, end = “AACCGGTA”, bank = [“AACCGGTA”]

2024-08-04 17:41:39 285

原创【LeetCode】课程表 II

要学习课程 3，你应该先完成课程 1 和课程 2。输入：numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]因此，正确的课程顺序为 [0,1]。因此，一个正确的课程顺序是 [0,1,2,3]。另一个正确的排序是 [0,2,1,3]。例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示：[0,1]。输入：numCourses = 2, prerequisites = [[1,0]]输出：[0,2,1,3]

2024-08-04 16:44:57 322

原创【LeetCode】课程表

先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则必须先学习课程 bi。，每次访问过的时候设置一个状态，当再次遇到了这个节点的时候，则说明遇到了环，也即图中存在环，就无法完成所有课程。输入：numCourses = 2, prerequisites = [[1,0],[0,1]]例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1。学习课程 1 之前，你需要完成课程 0。

2024-08-04 14:16:56 410

原创【LeetCode】二叉树的锯齿形层序遍历

给你二叉树的根节点 root ，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。简单的一个思路就是普通的层序遍历，放到答案数组中，最后在对数组中的元素，隔一个进行一次反转就好了。输入：root = [3,9,20,null,null,15,7]输出：[[3],[20,9],[15,7]]树中节点数目在范围 [0, 2000] 内。输入：root = [1]输入：root = []

2024-07-29 23:34:26 178 1

原创【LeetCode】路径总和

判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum。输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22。输入：root = [1,2,3], targetSum = 5。解释：由于树是空的，所以不存在根节点到叶子节点的路径。不存在 sum = 5 的根节点到叶子节点的路径。解释：等于目标和的根节点到叶节点路径如上图所示。叶子节点是指没有子节点的节点。

2024-07-22 22:17:14 384

原创【LeetCode】二叉树展开为链表

展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null。可以先画一个图，手动将展开链表操作的流程执行一下，然后就按照手动的流程，来写代码。输出：[1,null,2,null,3,null,4,null,5,null,6]进阶：你可以使用原地算法（O(1) 额外空间）展开这棵树吗？输入：root = [1,2,5,3,4,null,6]树中结点数在范围 [0, 2000] 内。输入：root = [0]输入：root = []

2024-07-22 21:29:08 202

原创【LeetCode】填充每个节点的下一个右侧节点指针 II

解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），‘#’ 表示每层的末尾。填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。使用递归解题也符合要求，本题中递归程序的隐式栈空间不计入额外空间复杂度。输入：root = [1,2,3,4,5,null,7]输出：[1,#,2,3,#,4,5,7,#]

2024-07-21 21:33:20 417

原创【LeetCode】从中序与后序遍历序列构造二叉树

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗二叉树。输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]输入：inorder = [-1], postorder = [-1]简单的做法，和【前序+中序构造二叉树】一样，对数组进行分割就好了。输出：[3,9,20,null,null,15,7]后序序列：9 15 7 20 3。

2024-07-21 21:17:02 1207 1

原创【LeetCode】从前序与中序遍历序列构造二叉树

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]输入: preorder = [-1], inorder = [-1]输出: [3,9,20,null,null,15,7]preorder 和 inorder 均无重复元素。inorder 均出现在 preorder。

2024-07-21 19:42:12 374

原创【LeetCode】对称二叉树

输入：root = [1,2,2,null,3,null,3]给你一个二叉树的根节点 root ，检查它是否轴对称。输入：root = [1,2,2,3,4,4,3]进阶：你可以运用递归和迭代两种方法解决这个问题吗？使用递归，往下对称着看就好了，反正节点传到函数。树中节点数目在范围 [1, 1000] 内。里面，又不用管它俩到底相距的有多远，。

2024-07-21 19:27:47 442

原创【LeetCode】翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。输入：root = [4,2,7,1,3,6,9]，所以要写到一个自定义函数里，最后将结果返回。树中节点数目范围在 [0, 100] 内。输出：[4,7,2,9,6,3,1]输入：root = [2,1,3]就正常交换，但注意题目要求返回。输入：root = []输出：[2,3,1]

2024-07-20 23:01:56 264

原创【LeetCode】相同的树

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。同时遍历二叉树就好了，聚焦于当前两节点，后续的交给下一个栈来做。输入：p = [1,2], q = [1,null,2]输入：p = [1,2,3], q = [1,2,3]输入：p = [1,2,1], q = [1,1,2]两棵树上的节点数目都在范围 [0, 100] 内。

2024-07-20 22:53:53 216

原创【LeetCode】二叉树的最大深度

二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。输入：root = [3,9,20,null,null,15,7]给定一个二叉树 root ，返回其最大深度。树中节点的数量在 [0, 104] 区间内。输入：root = [1,null,2]递归就好了，当前如果是空，就返回。，否则返回左右子树最大深度。

2024-07-20 22:40:13 487 1

原创【LeetCode】分隔链表

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当保留两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]

2024-07-20 22:34:59 439

原创【LeetCode】旋转链表

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。输入：head = [1,2,3,4,5], k = 2。输入：head = [0,1,2], k = 4。链表中节点的数目在范围 [0, 500] 内。个节点，然后做断开重新连接的动作。输出：[4,5,1,2,3]输出：[2,0,1]

2024-07-20 22:29:34 408

原创【LeetCode】删除排序链表中的重复元素 II

给定一个已排序的链表的头 head ，删除原始链表中所有重复数字的节点，只留下不同的数字。返回已排序的链表。输入：head = [1,2,3,3,4,4,5]先遍历一边链表，利用哈希表记录每个数字出现了多少次。输入：head = [1,1,1,2,3]链表中节点数目在范围 [0, 300] 内。然后再遍历一边，跳过哪些所有出现次数超过。题目数据保证链表已经按升序排列。输出：[1,2,5]

2024-07-17 22:15:37 278

原创【LeetCode】K 个一组翻转链表

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-07-17 21:41:03 321

原创【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 273

原创【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 275

原创【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 381

原创【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 280

原创【LeetCode】有效的括号

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

2024-07-14 15:40:56 240

原创【LeetCode】简化路径

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

2024-07-14 15:21:25 299

原创【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 280

原创【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 326 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 283

原创【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 387

原创【LeetCode】快乐数

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

2024-07-11 21:25:20 286

原创【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 258

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

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

2024-07-10 21:56:25 307

空空如也

空空如也