吃着火锅x唱着歌-CSDN博客

原创深度探索C++对象模型学习笔记第六章执行期语意学（1）

假设我们有下面这个看起来简单的表达式：其中 xx 和 yy 定义如下：class Y 的定义是：class X 的定义是：很简单，对吧？好，我们来看看这个表达式到底是如何被处理的。首先，我们需要确定实际使用的是哪个相等运算符实例。这里解析到了 Y 类重载的成员运算符。这是表达式的第一次转换：Y 的相等运算符需要一个 Y 类型的参数。但 getValue() 返回的却是 X 类型的对象。那么，要么存在一种将 X 对象转换为 Y 对象的方法，否则表达式就是错误的。在本例中，X 提供了一个转换

2026-06-15 22:59:37 41

原创 LeetCode 2336.无限集中的最小数字

如果有n个数字，则每次popSmallest和addBack操作的时间复杂度为O(logn)，总空间复杂度为O(n)。// 返回 1 ，因为 1 是最小的整数，并将其从集合中移除。SmallestInfiniteSet() 初始化 SmallestInfiniteSet 对象以包含所有正整数。// 返回 2 ，并将其从集合中移除。// 返回 3 ，并将其从集合中移除。// 返回 4 ，并将其从集合中移除。// 返回 5 ，并将其从集合中移除。// 且 1 是最小的整数，并将其从集合中移除。

2026-06-15 22:05:51 38

原创 LeetCode 2558.从数量最多的堆取走礼物

如果gifts的长度为n，则此算法时间复杂度为O(n + klogn)，空间复杂度为O(1)。给你一个整数数组 gifts ，表示各堆礼物的数量。输入：gifts = [25,64,9,4,100], k = 4。将堆中的礼物数量减少到堆中原来礼物数量的平方根，向下取整。输入：gifts = [1,1,1,1], k = 4。在本例中，不管选中哪一堆礼物，都必须剩下 1 个礼物。如果不止一堆都符合礼物数量最多，从中选择任一堆即可。也就是说，你无法获取任一堆中的礼物。所以，剩下礼物的总数量是 4。

2026-06-14 17:17:33 224

原创 LeetCode 1046.最后一块石头的重量

y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。如果stones的大小为n，则此算法时间复杂度为O(nlogn)，空间复杂度为O(1)。最后选出 1 和 1，得到 0，最终数组转换为 [1]，这就是最后剩下那块石头的重量。先选出 7 和 8，得到 1，所以数组转换为 [2,4,1,1,1]，再选出 2 和 4，得到 2，所以数组转换为 [2,1,1,1]，接着是 2 和 1，得到 1，所以数组转换为 [1,1,1]，输入：[2,7,4,1,8,1]

2026-06-13 20:09:40 232

原创 LeetCode 1438.绝对差不超过限制的最长连续子数组

解释：满足题意的最长子数组是 [2,4,7,2]，其最大绝对差 |2-7| = 5 <= 5。输入：nums = [4,2,2,2,4,4,2,2], limit = 0。输入：nums = [10,1,2,4,7,2], limit = 5。输入：nums = [8,2,4,7], limit = 4。[8,2,4,7] 最大绝对差 |8-2| = 6 > 4.[2,4,7] 最大绝对差 |2-7| = 5 > 4.[2,4] 最大绝对差 |2-4| = 2 <= 4.

2026-06-11 20:51:05 180

原创 LeetCode LCR 184.设计自助结算系统

如果有n个商品，则此算法各操作的时间复杂度为O(1)，空间复杂度为O(n)。add(value)：将价格为 value 的商品加入待结算商品队列的尾部。get_max()：获取结算商品中的最高价格，如果队列为空，则返回 -1。remove()：移除第一个待结算的商品价格，如果队列为空，则返回 -1。注意，为保证该系统运转高效性，以上函数的均摊时间复杂度均为 O(1)输出: [null,null,null,7,4,7]输出: [null,-1,-1]

2026-06-10 21:08:20 152

原创 LeetCode 239.滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。如果nums的大小为n，其中的元素种类为m，则此算法时间复杂度为O(n)，空间复杂度为O(min(m,k))。输入：nums = [1,3,-1,-3,5,3,6,7], k = 3。滑动窗口的位置最大值。输入：nums = [1], k = 1。输出：[3,3,5,5,6,7]返回滑动窗口中的最大值。

2026-06-09 20:53:19 234

原创深度探索C++对象模型学习笔记第五章构造、解构、拷贝语意学（2）

更一般地说，在某个类（这里即 Point3d 类）的构造函数（以及析构函数）内部，正在构造的对象（这里是 PVertex 对象）对虚函数的调用，被限定在该类（即 Point3d 类）内部活动的虚函数版本上。禁止拷贝的方法是：将拷贝赋值运算符声明为 private，并且不提供定义（声明为私有后，除了类的成员函数和友元之外，其他地方都无法进行赋值，而我们又不提供定义，这样一来，如果有成员函数或友元试图进行拷贝，程序就会链接失败，诚然，依赖链接器的特性——也就是依赖语言外部的东西——并不完全令人满意）。

2026-06-08 22:16:41 239

原创 LeetCode 1670.设计前中后队列

从 [1, 2, 3, 4, 5, 6] 的中间位置弹出元素，返回 3 ，数组变为 [1, 2, 4, 5, 6]。int popMiddle() 将正中间的元素从队列中删除并返回值，如果删除之前队列为空，那么返回 -1。将 6 添加到 [1, 2, 3, 4, 5] 的中间位置，结果数组为 [1, 2, 6, 3, 4, 5]。int popFront() 将最前面的元素从队列中删除并返回值，如果删除之前队列为空，那么返回 -1。// 返回 1 -> [4, 3, 2]

2026-06-06 16:51:46 192

原创 LeetCode 649.Dota2参议院

空间复杂度为O(1)。如果senate的长度为n，则此算法时间复杂度为O(n)，每次循环都会使一个参议员失去权利，空间复杂度为O(n)。宣布胜利：如果参议员发现有权利投票的参议员都是同一个阵营的，他可以宣布胜利并决定在游戏中的有关变化。第 1 轮时，第一个来自 Radiant 阵营的参议员可以使用第一项权利禁止第二个参议员的权利。这一轮中，第三个来自 Dire 阵营的参议员可以使用他的第一项权利禁止第一个参议员的权利。这一轮中，第二个来自 Dire 阵营的参议员会将被跳过，因为他的权利被禁止了。

2026-06-06 00:16:34 148

原创 LeetCode 950.按递增顺序显示卡牌

我们得到的牌组顺序为 [17,13,11,2,3,5,7]（这个顺序不重要），然后将其重新排序。重新排序后，牌组以 [2,13,3,11,5,17,7] 开始，其中 2 位于牌组的顶部。牌组现在是 [3,11,5,17,7,13]。牌组现在是 [5,17,7,13,11]。牌组现在是 [7,13,11,17]。牌组现在是 [11,17,13]。2.如果牌组中仍有牌，则将下一张处于牌组顶部的牌放在牌组的底部。输入：[17,13,11,2,3,5,7]输出：[2,13,3,11,5,17,7]

2026-06-04 23:28:37 200

原创 LeetCode 3829.设计共享出行系统

int[] matchDriverWithRider() 匹配最早到达的空闲司机和最早等待的乘客，并将这两者从系统中移除。如果有n个司机，m个乘客，则此算法司机和乘客加入队列的时间复杂度为O(1)，匹配的时间复杂度为O(1)，乘客取消匹配的时间复杂度为O(m)，空间复杂度为O(n+m)。void cancelRider(int riderId) 取消指定 riderId 的乘客的叫车请求，前提是该乘客存在并且尚未被匹配。// 返回 [-1, -1]// 返回 [-1, -1]// 返回 [5, 1]

2026-06-03 22:14:41 256

原创 LeetCode 84.柱状图中最大的矩形

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1。如果heights的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(n)。输入：heights = [2,1,5,6,2,3]求在该柱状图中，能够勾勒出来的矩形的最大面积。解释：最大的矩形为图中红色区域，面积为 10。输入： heights = [2,4]

2026-06-02 23:51:54 227

原创 LeetCode 962.最大宽度坡

给定一个整数数组 A，坡是元组 (i, j)，其中 i < j 且 A[i] <= A[j]。最大宽度的坡为 (i, j) = (1, 5): A[1] = 0 且 A[5] = 5.最大宽度的坡为 (i, j) = (2, 9): A[2] = 1 且 A[9] = 1.如果nums的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(n)。找出 A 中的坡的最大宽度，如果不存在，返回 0。输入：[9,8,1,0,1,9,4,0,4,1]输入：[6,0,8,2,1,5]

2026-05-20 22:22:47 83

原创深度探索C++对象模型学习笔记第五章构造、解构、拷贝语意学（1）

遗憾的是，我手头没有实际采用这种方案的编译器，因此无法提供数据来证实这一点（不过，在 Foundation 项目期间，Rob Murray——我猜他是出于无奈——手动优化了 cfront 生成的 C 代码，消除了不必要的条件测试和虚表指针设置。而local中的三个成员值会是随机值，因为默认构造函数中没有为三个成员设置初始值，即使是我们显式提供的构造函数，如果没有为成员设置初始值，成员的初始值也是随机的。但在实际实现中，这些平凡成员既不会被定义，也不会被调用，程序的行为和 C 语言下完全一样。

2026-05-20 00:03:09 365

原创 LeetCode 1019.链表中的下一个更大节点

返回一个整数数组 answer ，其中 answer[i] 是第 i 个节点( 从1开始 )的下一个更大的节点的值。如果第 i 个节点没有下一个更大的节点，设置 answer[i] = 0。也就是说，对于每个节点，找到它旁边的第一个节点的值，这个节点的值严格大于它的值。如果链表长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(n)。输入：head = [2,7,4,3,5]给定一个长度为 n 的链表 head。输入：head = [2,1,5]输出：[7,0,5,5,0]输出：[5,5,0]

2026-05-18 21:02:45 82

原创 LeetCode 503.下一个更大元素II

给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。解释: 第一个 1 的下一个更大的数是 2；输入: nums = [1,2,3,4,3]输入: nums = [1,2,1]数字 2 找不到下一个更大的数；输出: [2,3,4,-1,4]输出: [2,-1,2]

2026-05-17 18:27:57 58

原创 LeetCode 496.下一个更大元素I

对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的下一个更大元素。给你两个没有重复元素的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。输入：nums1 = [4,1,2], nums2 = [1,3,4,2].输入：nums1 = [2,4], nums2 = [1,2,3,4].输出：[-1,3,-1]

2026-05-14 21:55:37 313

原创 LeetCode 1475.商品折扣后的最终价格

商店里正在进行促销活动，如果你要买第 i 件商品，那么你可以得到与 prices[j] 相等的折扣，其中 j 是满足 j > i 且 prices[j] <= prices[i] 的最小下标，如果没有满足条件的 j ，你将没有任何折扣。商品 1 的价格为 price[1]=4 ，你将得到 prices[3]=2 的折扣，所以最终价格为 4 - 2 = 2。商品 2 的价格为 price[2]=6 ，你将得到 prices[3]=2 的折扣，所以最终价格为 6 - 2 = 4。

2026-05-14 12:37:02 43

原创 LeetCode 739.每日温度

给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。输入: temperatures = [73,74,75,71,69,72,76,73]输入: temperatures = [30,40,50,60]输入: temperatures = [30,60,90]输出: [1,1,4,2,1,1,0,0]输出: [1,1,1,0]输出: [1,1,0]

2026-05-13 22:07:03 70

原创 LeetCode 726.原子的数量

此时curCnt最多只会有一个原子，出栈时也只会有1个原子，但出栈阶段curCnt会线性增长到O(n)级别，每次出栈都会遍历curCnt，让curCnt的每个原子重复括号后的数字次，因此内层循环也需要O(n)时间；返回所有原子的数量，格式为：第一个（按字典序）原子的名字，跟着它的数量（如果数量大于 1），然后是第二个原子的名字（按字典序），跟着它的数量（如果数量大于 1），以此类推。解释：原子的数量是 {‘K’: 4, ‘N’: 2, ‘O’: 14, ‘S’: 4}。如果数量等于 1 则不会跟数字。

2026-05-12 23:16:14 80

原创 LeetCode 227.基本计算器 II

所有中间结果将在 [-231, 231 - 1] 的范围内。s 由整数和算符 (‘+’, ‘-’, ‘*’, ‘/’) 组成，中间由一些空格隔开。注意：不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval()。给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。如果s的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(n)。表达式中的所有整数都是非负整数，且在范围 [0, 2。输入：s = " 3+5 / 2 "输入：s = " 3/2 "整数除法仅保留整数部分。

2026-05-06 20:50:20 34

原创深度探索C++对象模型学习笔记第四章 Function语意学（2）

但总的来说，目前的链接器在执行这种清理时，并不会一并清除随调用生成的调试信息——这可以通过 UNIX 的 strip 命令（该命令会从可执行文件、目标文件、共享库中移除符号表、调试信息和重定位信息，从而显著减小文件的体积，好处在于可使得逆向分析更加困难，以及提升发布版本的加载速度并降低存储成本）来完成。显然，这种复杂度度量中给各项赋予的具体数值是存在争议的。不过请注意：如果一个内联函数在程序中被调用太多次，那么它的展开代码总量，可能会远远超出你从它的定义表面所看到的规模，从而引发意想不到的代码膨胀。

2026-04-27 13:05:54 415

原创 LeetCode 8.字符串转换整数 (atoi)

第 2 步：“1337c0d3”（当前没有读入字符，因为这里不存在 ‘-’ 或者 ‘+’）第 2 步：“0-1” (当前没有读入字符，因为这里不存在 ‘-’ 或者 ‘+’)第 2 步：“42”（当前没有读入字符，因为这里不存在 ‘-’ 或者 ‘+’）第 2 步：" -042"（读入 ‘-’ 字符，所以结果应该是负数）第 1 步：“1337c0d3”（当前没有读入字符，因为没有前导空格）第 1 步：“0-1” (当前没有读入字符，因为没有前导空格)第 1 步：" -042"（读入前导空格，但忽视掉）

2026-04-24 21:15:10 255

原创 LeetCode 394.字符串解码

编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。如果s的长度为n，以上代码中k的值为m，则此算法时间复杂度为O(m。输入：s = “2[abc]3[cd]ef”输入：s = “3[a]2[bc]”输入：s = “3[a2[c]]”输出：“accaccacc”

2026-04-24 13:06:38 45

原创深度探索C++对象模型学习笔记第四章 Function语意学（1）

假设我们有一个 Point3d 指针和对象：问题在于，当我们写下：时，实际会发生什么？其中 Point3d::normalize() 的实现如下：而 Point3d::magnitude() 的实现为：答案是：我们尚不得而知。C++ 支持三类成员函数：静态、非静态和虚函数。三者的调用方式各不相同，这些差异正是下一节要讨论的主题（小测验一则：尽管我们无法断言 normalize() 和 magnitude() 究竟是虚函数还是非虚成员，但可以放心地将它们排除在静态函数之外，因为这两者（a）都

2026-04-21 21:33:20 383

原创 LeetCode 150.逆波兰表达式求值

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”,“*”]

2026-04-16 21:18:16 276

原创 LeetCode 1006.笨阶乘

例如，clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。例如，factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1。相反，我们设计了一个笨阶乘 clumsy：在整数的递减序列中，我们以一个固定顺序的操作符序列来依次替换原有的乘法操作符：乘法(*)，除法(/)，加法(+)和减法(-)。这保证结果是一个整数。解释：12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。

2026-04-15 22:19:34 59

原创 LeetCode 678.有效的括号字符串

遍历s，维护一个左括号比右括号多的数量leftNum，每当遇到左括号增加leftNum，每当遇到右括号就减少leftNum。如果遇到星号，由于它可以变为左括号或右括号，因此我们可以同时维护两种情况，做法是把leftNum分为leftMinNum和leftMaxNum，如果星号变为左括号，就增加leftMaxNum，如果变为右括号就减少leftMinNum。‘*’ 可以被视为单个右括号 ‘)’ ，或单个左括号 ‘(’ ，或一个空字符串 “”。任何右括号 ‘)’ 必须有相应的左括号 ‘(’。

2026-04-15 21:18:42 73

原创 LeetCode 1963.使字符串平衡的最小交换次数

我们可以遍历字符串s，并记录遍历到的左括号和有括号的数量，正常情况下，一个平衡字符串的某个前缀中，一定是左括号的数量大于等于右括号的数量，因为左括号一定在左边。因此，如果遍历过程中发现左括号数量小于右括号数量了，那么当前遍历到的右括号一定需要交换，但我们并不需要真的从右边找一个左括号与之交换，只需要记录下来wrongNum，每次遇到右括号比左括号多的情况就将wrongNum加1即可。开括号 ‘[’ 的数目为 n / 2 ，闭括号 ‘]’ 的数目也是 n / 2。输入：s = “]]][[[”

2026-04-13 23:23:15 78

原创深度探索C++对象模型学习笔记第三章 Data语意学（2）

当然，更重要的一点是，优化器能够将这三种访问方式的性能拉平到同一水平，唯独NCC优化器表现异常（这里值得注意的是，NCC生成的可执行文件在开启优化后性能仍惨不忍睹，反映的是其生成的汇编代码优化质量糟糕，而不是C++源码层面的属性问题。这种重新排序的好处是，可以避免在派生类对象中额外生成一个 vptr（可能指的是把派生类的vptr放到基类的虚表里，而且只有第一个基类有虚函数时才这样做，C++标准只规定了虚函数的语义，并未规定vptr的实现细节，原文这一点了解即可）。然而，取成员地址所返回的值，总是会被加一。

2026-04-10 20:58:29 391

原创深度探索C++对象模型学习笔记第三章 Data语意学（1）

传统上，它被放在类所有显式声明的成员之后。Point2d 和 Point3d 类的声明与使用方式，与它们作为两个独立类时相比并无变化——因此，使用这些抽象的程序员无需关心这些对象究竟是相互独立的类类型，还是通过继承关联起来的。在这种情况下，我们无法确定 pt 实际指向的是哪种具体的类类型（因此也就无法在编译时得知该成员的实际偏移量），所以对该成员的访问必须通过额外的间接层推迟到运行时才能解析。例如，在一个访问段中声明八个成员，与在八个独立的访问段中分别声明这些成员，在实践中生成的类对象大小是完全相同的。

2026-03-29 19:08:10 391

原创 PHP7内核剖析学习笔记第十章扩展开发（3）

类的注册是通过zend_register_internal_class()完成的，注册时传入的zend_class_entry并不是最终插入EG(class_table)的结构，因此参数可分配在栈上。上图中，zend_hash_init的最后一个参数不能是使用持久化，因为ZVAL_NEW_ARR()分配的zend_array是非持久化的，可使用ZVAL_NEW_PERSISTENT_ARR(z)代替ZVAL_NEW_ARR。然后初始化数组，可通过zend_hash_init()宏完成。

2026-03-15 15:36:30 358

原创 LeetCode 1249.移除无效的括号

你需要从字符串中删除最少数目的 ‘(’ 或者 ‘)’ （可以删除任意位置的括号)，使得剩下的「括号字符串」有效。解释：“lee(t(co)de)” , “lee(t©ode)” 也是一个可行答案。可以被写作 AB（A 连接 B）的字符串，其中 A 和 B 都是有效「括号字符串」如果s的长度为n，那么此算法时间复杂度为O(n)，空间复杂度为O(n)。可以被写作 (A) 的字符串，其中 A 是一个有效的「括号字符串」输入：s = “lee(t©o)de)”输入：s = “a)b©d”输入：s = “))((”

2026-03-12 23:01:20 66

空空如也

空空如也