- 博客(53)
- 收藏
- 关注
RSS订阅原创 C/C++---------------LeetCode第509. 斐波那契数
这里的f(18)前面已经计算过，在计算f(19)的时候又要计算f(18)大大减小了代码的效率，这个时候可以使用备忘录将前面计算的f(18)保存到备忘录里，下一次计算的时候先去备忘录查看之前有没有计算过这个，如果计算过直接返回结果来用即可。思路：想要计算原问题 f(20)，我就得先计算出子问题 f(19) 和 f(18)，然后要计算 f(19)，我就要先算出子问题 f(18) 和 f(17)解释：F(3) = F(2) + F(1) = 1 + 1 = 2。给定 n ，请计算 F(n)。
2023-12-10 19:19:31
273
1
原创 C/C++---------------LeetCode第374. 猜数字大小
思路：基础的二分查找，正确的数字和猜的数字进行对比并不断更新区间直到找到这个数，否则返回-1。请你猜选出的是哪个数字。0：我选出的数字和你猜的数字一样。如果你猜错了，我会告诉你，你猜测的数字比我选出的数字是大了还是小了。-1：我选出的数字比你猜的数字小 pick < num。1：我选出的数字比你猜的数字大 pick > num。输入：n = 10, pick = 6。输入：n = 1, pick = 1。输入：n = 2, pick = 1。输入：n = 2, pick = 2。
2023-12-07 23:22:50
275
1
原创 C/C++---------------LeetCode第278. 第一个错误的版本
isBadVersion 函数会接受一个版本号作为参数，并返回一个布尔值来指示该版本是否有问题。例如，如果 isBadVersion(3) 返回 true，则表示版本 3 存在问题；不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。输入：n = 5, bad = 4。输入：n = 1, bad = 1。所以，4 是第一个错误的版本。
2023-12-07 23:09:34
275
原创 C/C++---------------LeetCode第2154. 将找到的值乘以 2
如果在 nums 中找到 original ，将 original 乘以 2 ，得到新 original（即，令 original = 2 * original）。给你一个整数数组 nums ，另给你一个整数 original ，这是需要在 nums 中搜索的第一个数字。思路：将nums全部存入hash，查找original，找到了就*2，直到找不到original。输入：nums = [5,3,6,1,12], original = 3。输入：nums = [2,7,9], original = 4。
2023-12-06 23:14:11
352
原创 C/C++查找算法-----------------------二分查找详解
二分查找也称折半查找，搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。
2023-12-06 23:13:33
482
原创 C/C++---------------LeetCode第118. 杨辉三角
接着计算中间的元素，这些元素等于它正上方的元素和左上方的元素之和，即 dp[i-1][j] + dp[i-1][j-1]。2、除了每行的第一个数和最后一个数是1以外，任意其他位置的数，都是它正上方的数和左上方的数之和。输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]每行的最后一个元素也是1，同样使用 emplace_back 添加到当前行。每行的第一个元素是1，使用 emplace_back 添加到当前行。输入: numRows = 1。1、第一行只有一个数1。
2023-12-05 21:42:00
195
原创 C/C++---------------LeetCode第350. 两个数组的交集 II
思路：先排好序，定义两个指针分别指向nums1和nums2，然后哪个指针指向的值小的话就移动那个指针 ，例如排好序的数组为nums1=1,5,8 nums2=3,5,9，指针分别指向第一个元素，1和5，nums1指向的1小于nums2指向的3，移动nums1的指针到下一个，这个时候nums1指向5，nums2还是指向1，这个时候nums2比较小，这个时候移动nums2的指针，这个时候nums1和nums2都指向了5构成了交集，存入数组，当指针超出数组时退出循环返回存放交集的数组即可。
2023-12-05 21:18:35
318
原创 C/C++---------------LeetCode第876. 链表的中间结点
思路：分别定义快慢指针即慢指针一次走一步，快指针一次走两步，当链表长度为奇数的时候fast走到尾结点的时候slow刚好就走到了中间结点，当链表长度为偶数的时候fast走到null的时候slow则刚好走到第二个中间结点，只需要返回slow即可。给你单链表的头结点 head ，请你找出并返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
2023-12-01 19:54:06
295
原创 C/C++---------------LeetCode第27. 移除元素
思路：定义两个指针，left和right，如果right的值不等于val的话就说明不用移除这个元素，将right的值放到left的位置上并且两个指针都向右移，如果出现right的值等于val的话只需要把right的值向右移动，跳过值等于val的位置，最后的left就是数组的长度。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。输入：nums = [0,1,2,2,3,0,4,2], val = 2。元素的顺序可以改变。
2023-12-01 19:42:51
365
原创 C/C++---------------LeetCode第35. 搜索插入位置
思路：使用二分查找，首先初始化左右指针，然后在每一次循环中，计算中间位置 mid，并与目标值进行比较。如果中间位置的元素等于目标值，则返回该位置，如果中间位置的元素大于目标值，则将右指针移动到 mid - 1 的位置，如果中间位置的元素小于目标值，则将左指针移动到 mid + 1 的位置。输入: nums = [1,3,5,6], target = 5。输入: nums = [1,3,5,6], target = 2。输入: nums = [1,3,5,6], target = 7。
2023-11-28 16:50:55
181
原创 C/C++---------------LeetCode第229. 多数元素 II
给定一个大小为 n 的整数数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。进阶：尝试设计时间复杂度为 O(n)、空间复杂度为 O(1)的算法解决此问题。思路：存入哈希表，然后遍历哈希找出符合的数存入到ans中即可。输入：nums = [3,2,3]输入：nums = [1,2]输入：nums = [1]时间复杂度为:O(n)空间复杂度为:O(n)
2023-11-26 19:59:37
193
原创 C/C++---------------LeetCode第1512. 好数对的数目
如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i < j ，就可以认为这是一组 好数对。解释：有 4 组好数对，分别是 (0,3), (0,4), (3,4), (2,5) ，下标从 0 开始。思路：将出现的次数存入哈希然后去判断并不断更新goodpairs的值，最后返回即可。思路：双循环每个数字都遍历过去，符合要求ans自增，最后返回ans即好数对的数目。输入：nums = [1,2,3,1,1,3]输入：nums = [1,1,1,1]输入：nums = [1,2,3]
2023-11-24 20:53:38
316
原创 C/C++---------------LeetCode第2824. 统计和小于目标的下标对数目
给你一个下标从 0 开始长度为 n 的整数数组 nums 和一个整数 target ，请你返回满足 0
2023-11-24 20:35:53
593
原创 C/C++---------------LeetCode第2540. 最小公共值
给你两个整数数组 nums1 和 nums2 ，它们已经按非降序排序，请你返回两个数组的 最小公共整数。思路：出现次数存入哈希表，然后再遍历nums2检查是否有重复的，然后将它输出，因为这是一个非降序的所以它是递增，输出第一个重复的就是最小的公共整数。输入：nums1 = [1,2,3,6], nums2 = [2,3,4,5]解释：两个数组中的公共元素是 2 和 3 ，2 是较小值，所以返回 2。输入：nums1 = [1,2,3], nums2 = [2,4]
2023-11-23 21:22:09
389
原创 C/C++---------------LeetCode第1436. 旅行终点站
解释：从 “London” 出发，最后抵达终点站 “Sao Paulo”。本次旅行的路线是 “London” -> “New York” -> “Lima” -> “Sao Paulo”。输入：paths = [[“London”,“New York”],[“New York”,“Lima”],[“Lima”,“Sao Paulo”]]输入：paths = [[“B”,“C”],[“D”,“B”],[“C”,“A”]]输入：paths = [[“A”,“Z”]]输出：“Sao Paulo”
2023-11-23 15:03:04
192
原创 C/C++---------------LeetCode第1207.独一无二的出现次数
思路：创建两个哈希，先遍历hash，将键值对插入到hash1，这样就可以得到包含所有不同出现次数的hash1，然后去判断hash1是否等于hash的大小，如果相等则返回true表示每个元素出现的次数都是唯一的，否则就返回false表示存在重复的出现次数。解释：在该数组中，1 出现了 3 次，2 出现了 2 次，3 只出现了 1 次。没有两个数的出现次数相同。输入：arr = [-3,0,1,-3,1,1,1,-3,10,0]输入：arr = [1,2,2,1,1,3]输入：arr = [1,2]
2023-11-20 17:06:47
304
原创 C/C++---------------LeetCode第349.两个数组的交集
给定两个数组 nums1 和 nums2 ，返回 它们的交集。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序。思路：创建两个哈希表分别储存nums1和nums2，然后和遍历其中一个去比较是否有一样的值，如果有的话就存入ans，最后返回ans即可。输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]输入：nums1 = [1,2,2,1], nums2 = [2,2]解释：[4,9] 也是可通过的。
2023-11-20 16:42:27
244
原创 C/C++---------------LeetCode第LCR. 024.反转链表
思路：遍历链表，并在访问各节点时修改 next 引用指向，首先，检查链表是否为空或者只有一个节点，如果是的话直接返回原始的头节点，然后使用三个指针来迭代整个链表：prev（前一个节点）、curr（当前节点）和nextNode（下一个节点），在每一步迭代中，将curr的next指针指向prev，然后更新prev和curr指针为下一个节点，直到遍历完整个链表。最后返回新的头节点prev，即原链表的尾节点。这样就完成了链表的反转操作。时间复杂度：O(n)空间复杂度：O(1)
2023-11-17 17:45:34
311
原创 C/C++算法-----------------------双指针详解技巧及例题
双指针（two poinnters）实际上是一种算法编程里的一种思想，它更像是一种编程思想，提供看非常高的算法效率，一般来说双指针指的是在遍历对象时使用两个或多个指针遍历进行操作，经常可以用来降低时间复杂度，那么双指针主要分为以下三种：普通的指针：两个指针往一个方向移动对撞指针：一般是在有序的情况下两个指针进行面对面的移动，适合解决约束条件的一组元素问题以及字符串反转问题快慢指针：定义两个指针，一个快指针一个慢指针，用于判断是否为环或者长度的问题很方便。
2023-11-17 11:38:04
1165
1
原创 C/C++---------------LeetCode第1189. “气球” 的最大数量
思路：统计每个单词出现的次数，因为字母l和o需要用两次，所以除2，最后返回字母中数量最小值即为可以构成的单词数量。给你一个字符串 text，你需要使用 text 中的字母来拼凑尽可能多的单词 “balloon”（气球）。字符串 text 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 “balloon”。输入：text = “leetcode”text 全部由小写英文字母组成。
2023-11-16 22:10:47
397
原创 C/C++---------------LeetCode第128. 最长连续序列
思路：遍历哈希表，先判断是否为这个序列的起点，例如80，80-1等于79如果存在于哈希表中则代表80不是起点，跳出if语句，如果80是七点的话则不断+1并判断这个数是否存在，最后不断迭代最长的序列长度即可。给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。解释：最长数字连续序列是 [1, 2, 3, 4]。输入：nums = [0,3,7,2,5,8,4,6,0,1]输入：nums = [100,4,200,1,3,2]
2023-11-16 15:50:31
440
1
原创 C/C++---------------LeetCode第1394.找出数组中的幸运数
思路：双层循环去找这个数并记录，如果找到这个幸运数则保存下来，如果出现了另外一个幸运数，则更新maxLucky为当前元素和maxLucky中较大的值。在整数数组中，如果一个整数的出现频次和它的数值大小相等，我们就称这个整数为「幸运数」。解释：数组中唯一的幸运数是 2 ，因为数值 2 的出现频次也是 2。输入：arr = [7,7,7,7,7,7,7]输入：arr = [1,2,2,3,3,3]输入：arr = [2,2,2,3,3]输入：arr = [2,2,3,4]解释：数组中不存在幸运数。
2023-11-15 23:52:15
680
3
原创 C/C++---------------LeetCode第560. 和为 K 的子数组
思路：我们遍历数组时，计算每个位置的前缀和，并将前缀和存储在哈希表中，当我们计算到第 i 个位置时，就可以检查哈希表中是否存在前面某个位置的前缀和等于 (当前前缀和 - k)，如果存在这样的前缀和，那么说明存在一个子数组的和为 k。给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的子数组的个数。输入：nums = [1,1,1], k = 2。输入：nums = [1,2,3], k = 3。前缀和：前缀和是指从数组开头到当前位置的元素之和。时间复杂度为O(n^2)
2023-11-15 14:41:35
323
1
原创 C/C++---------------LeetCode第1748.唯一元素的和
思路：先遍历一次哈希表并进行计数，再遍历一次找出只出现一次的数，然后累加到sum里。给你一个整数数组 nums。数组中唯一元素是那些只出现 恰好一次 的元素。解释：唯一元素为 [1,2,3,4,5] ，和为 15。解释：唯一元素为 [1,3] ，和为 4。输入：nums = [1,1,1,1,1]输入：nums = [1,2,3,4,5]请你返回 nums 中唯一元素的 和。输入：nums = [1,2,3,2]解释：没有唯一元素，和为 0。时间复杂度：O(n)空间复杂度：O(n)
2023-11-14 17:00:25
410
原创 C/C++---------------LeetCode第2011.执行操作后的变量值
思路：钻个空，比如- - X，和X - -，这里有三个字符，分别的下标为0,1，2，不管怎么改变，第二个位置也就是下标1一定是符号，++X,X++也一样。输入：operations = [“X++”,“++X”,“–X”,“X–”]X++：X 加 1 ，X = -1 + 1 = 0。X++：X 加 1 ，X = 0 + 1 = 1。++X：X 加 1 ，X = 0 + 1 = 1。++X：X 加 1 ，X = 1 + 1 = 2。X++：X 加 1 ，X = 0 + 1 = 1。
2023-11-14 16:37:43
201
原创 C/C++---------------LeetCode第49.字母异位词分组
在哈希表中找到键为 “aet” 的项，发现已存在，则将原始字符串 “tea” 加入到值的向量中以此类推，到最后遍历哈希表 hash 中的每一对键值对然后将他们全部输出就行。在哈希表中找到键为 “aet” 的项，发现不存在，则创建该键，并将原始字符串 “eat” 加入到值的向量中。输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]输出: [[“”]]
2023-11-13 21:29:29
372
原创 C/C++---------------LeetCode第771.宝石与石头
给你一个字符串 jewels 代表石头中宝石的类型，另有一个字符串 stones 代表你拥有的石头。stones 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。输入：jewels = “aA”, stones = “aAAbbbb”字母区分大小写，因此 “a” 和 “A” 是不同类型的石头。输入：jewels = “z”, stones = “ZZ”思路：全部枚举对比，出现一样的sum+1直到循环结束。jewels 中的所有字符都是 唯一的。
2023-11-13 21:04:38
264
原创 C/C++---------------LeetCode第383.赎金信
思路：将magazine字母次数存入哈希并计数，然后再遍历一遍ransomNote对比字母的次数够不够构成，如果不够的话就返回false，否则返回true。给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。输入：ransomNote = “aa”, magazine = “aab”输入：ransomNote = “aa”, magazine = “ab”输入：ransomNote = “a”, magazine = “b”
2023-11-10 15:34:24
126
2
原创 C/C++---------------LeetCode第141.环形链表
为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。思路：这道题主要在于判断是否为一个环，那么可以想到快慢指针，也就是定义一个慢指针和一个快指针，一个每次向前移动两个节点，另一个每次向前移动一个节点，在循环中如果为环那么快指针一定会和慢指针再次相遇，如果到最后一个空的节点则表示不为环。思路：用一个哈希表存储节点，一直遍历下去直到head为空，如果为空则表示不是环，如果不是空的话则会一直遍历下去，直到第二次遍历发现这个节点存在，表示是环。
2023-11-10 10:07:22
563
1
原创 C/C++---------------LeetCode第387.字符串中第一个唯一字符
给定一个字符串 s ，找到 它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。思路：进行两次循环，第一次计算字符出现的次数，第二次只需要找只出现一次的字符，然后将他输出。输入: s = “loveleetcode”输入: s = “leetcode”输入: s = “aabb”简单无脑又好玩，锻炼打字。
2023-11-09 16:23:20
283
1
原创 C/C++---------------LeetCode第202.快乐数
思路：每次都求出sum的平方和，因为题目说到会无限循环，用哈希去查找是否出现过，如果出现过则代表进入了无限，直接返回false，否则就一直算下去，知道n的值为1，则表示是快乐数。思路：快指针” 每次走两步，“慢指针” 每次走一步，当二者相等时，即为一个循环周期。此时，判断是不是因为 1 引起的循环，是的话就是快乐数，否则不是快乐数。对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。如果这个过程 结果为 1，那么这个数就是快乐数。编写一个算法来判断一个数 n 是不是快乐数。
2023-11-09 16:03:38
128
原创 C/C++---------------LeetCode第448.找到所有数组中消失的数字
思路：for循环遍历1到nums.size()的所有数字，对于每个数字i，通过num_set.find(i)来检查i是否在num_set中。给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。创建一个numset来存储数组中出现过的数字，然后遍历整数范围 1 到 n，检查哪些数字没有出现在集合中，将这些缺失的数字加入到结果数组中返回。进阶：你能在不使用额外空间且时间复杂度为 O(n) 的情况下解决这个问题吗?输入：nums = [4,3,2,7,8,2,3,1]
2023-11-08 10:49:18
176
原创 C/C++---------------LeetCode第LCP 17.速算机器人
在本次游戏中，店家说出的数字为 x = 1 和 y = 0，小扣说出的计算指令记作仅由大写字母 A、B 组成的字符串 s，字符串中字符的顺序表示计算顺序，请返回最终 x 与 y 的和为多少。解释： 经过一次 A 运算后，x = 2, y = 0。再经过一次 B 运算，x = 2, y = 2。最终 x 与 y 之和为 4。“A” 运算：使 x = 2 * x + y；“B” 运算：使 y = 2 * y + x。s 由 ‘A’ 和 ‘B’ 组成。思路：直接按照题目打就行了。输入：s = “AB”
2023-11-08 09:54:09
56
原创 C/C++---------------LeetCode第219 存在重复元素||
给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j)
2023-11-06 16:59:47
258
1
原创 C/C++---------------LeetCode第LCR 018.验证回文数
思路：定义两个指针分别指向字符串的开头和结尾进行逐一对比，如果出现所指的字符串不相等说明不是回文串返回false，否则返回true。给定一个字符串 s ，验证 s 是否是 回文串 ，只考虑字母和数字字符，可以忽略字母的大小写。输入: s = “A man, a plan, a canal: Panama”解释：“amanaplanacanalpanama” 是回文串。输入: s = “race a car”解释：“raceacar” 不是回文串。时间复杂度为：O(n)空间复杂度为：O(1)
2023-11-06 15:22:12
187
1
原创 C/C++---------------LeetCode第217. 存在重复元素
思路：创建哈希表，遍历哈希表，如果发现重复的值则返回true，如果没有发现则存入哈希表中，一但发现重复的则返回true，遍历到最后都没发现重复的则表示没有重复的值返回false。思路:不用思路，全凭暴力，直接全部枚举，出现一样的数直接返回true，都没出现返回false。输入：nums = [1,1,1,3,3,4,3,2,4,2]输入：nums = [1,2,3,1]输入：nums = [1,2,3,4]时间复杂度：O(n^2)空间复杂度为：O(1)空间复杂度为:O(n)空间复杂度为：O(1)
2023-11-05 23:27:56
72
1
原创 C/C++---------------LeetCode第169.多数元素
思路：通过使用哈希表记录每个元素的出现次数，并在遍历过程中判断元素是否出现次数超过一半，从而找到并返回出现次数超过一半的主要元素。思路：在摩尔投票算法中，当我们遍历数组时，遇到与候选多数元素不同的元素时，计数器 count 会减少。这个算法的核心在于，由于多数元素出现的次数超过了数组长度的一半，因此它的出现次数必定大于其他所有元素的出现次数之和。进阶：尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。输入：nums = [2,2,1,1,1,2,2]时间复杂度为：O(n^2)
2023-11-05 23:07:04
80
原创 C/C++---------------LeetCode第240. 搜索二维矩阵 II
输入：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。这题用贪心最优最优的策略：通过判断当前元素与目标值的大小关系，排除一行或一列，从而逐步缩小搜索范围。
2023-11-03 15:31:43
115
1
原创 C/C++------算法与数据结构---------哈希表基本定义和用法
哈希表是一个很常见也很好用的数据结构，在平时刷题时会经常遇到有时候使用起来也很事半功倍，在平时哈希表主要使用两种：unordered_set和unordered_map哈希表的英文叫 Hash Table，也可以称为散列表或者 Hash 表。哈希表存储的是由键（key）和值（value）组成的数据。例如，我们将每个人的性别作为数据进行存储，键为人名，值为对应的性别，其中 M 表示性别为男，F 表示性别为女。总结就是哈希表一般是用来快速判断某个元素是否出现在这个集合里。
2023-11-03 10:44:22
1018
1
原创 C/C++---------------LeetCode第2133. 检查是否每一行每一列都包含全部整数
解题思路：创建哈希集合，运用哈希集合中的count来判断当前列和行内的整数是否重复，若重复则不符合题目（都包含从 1 到 n 的 全部 整数）返回false，全部查找完之后没有重复的则返回一个true。对一个大小为 n x n 的矩阵而言，如果其每一行和每一列都包含从 1 到 n 的 全部 整数（含 1 和 n），则认为该矩阵是一个 有效 矩阵。输入：matrix = [[1,2,3],[3,1,2],[2,3,1]]输入：matrix = [[1,1,1],[1,2,3],[1,2,3]]
2023-11-03 09:38:45
77
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人