姚先生97-优快云博客

原创 LeetCode 贪心算法经典题目 (C++实现)

总结了贪心算法经典题目

2025-02-24 15:21:39 1535

原创 LeetCode 438. 找到字符串中所有字母异位词 (C++实现)

定义两个滑动窗口，分别为s_win和p_win，长度均为p字符串的长度，然后s_win从s的第一个字符串开始滑动，如果两个窗口相等记录起始位置。起始索引等于 0 的子串是 “cba”, 它是 “abc” 的异位词。起始索引等于 6 的子串是 “bac”, 它是 “abc” 的异位词。起始索引等于 0 的子串是 “ab”, 它是 “ab” 的异位词。起始索引等于 1 的子串是 “ba”, 它是 “ab” 的异位词。起始索引等于 2 的子串是 “ab”, 它是 “ab” 的异位词。输出: [0,1,2]

2025-01-12 11:56:00 317

原创 LeetCode 42. 接雨水 (C++实现)

先计算前缀数组pre，然后计算后缀数组suf，最后遍历height，每一位上的能接雨水的量等于min(pre[i], suf[i]) - height[i]解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]输入：height = [4,2,0,3,2,5]

2025-01-12 10:48:43 352

原创 LeetCode 128. 最长连续序列 (C++实现)

首先将nums所有元素映射为哈希表，然后遍历哈希表，如果num-1存在于哈希表，则跳过这一次循环，如果不存在，然后循环遍历num+1是否在哈希表中，同时记录长度。给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。输入：nums = [0,3,7,2,5,8,4,6,0,1]解释：唯一可能的三元组和不为 0。输入：nums = [0,1,1]

2025-01-12 09:49:15 170

原创 LeetCode 15. 三数之和 (C++实现)

首先将nums排序，然后遍历nums，定义左指针left和右指针right，如果nums[i] + nums[left] + nums[right]<0，左指针向右移动一位，如果nums[i] + nums[left] + nums[right]>0，右指针向左移动一位，如果nums[i] + nums[left] + nums[right] == 0，则记录nums[i]和nums[left]和nums[right]的位置。输出：[[-1,-1,2],[-1,0,1]]输出：[[0,0,0]]

2024-12-29 15:40:59 398

原创 LeetCode 202. 快乐数 (C++实现)

首先定义集合record，开始循环，获取n的每位数字平方和，然后判断这个和是不是1，是就返回true，不是的话再看这个和有没有在record里面出现过，出现过返回false，没出现过将这个和插入到record中。然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到1。如果 n 是快乐数就返回 true；不是，则返回 false。对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。如果这个过程结果为 1，那么这个数就是快乐数。编写一个算法来判断一个数 n 是不是快乐数。

2024-12-29 14:59:16 505

原创 LeetCode 349. 两个数组的交集 (C++实现)

首先定义一个用来记录元素有无的数组record，还有记录重复元素的集合ans，然后遍历nums1，记录nums1中的元素，然后遍历nums2，如果num2的元素在nums1中出现过，则压入ans，最后返回ans。给定两个数组 nums1 和 nums2 ，返回它们的交集。输出结果中的每个元素一定是唯一的。输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]输入：nums1 = [1,2,2,1], nums2 = [2,2]解释：[4,9] 也是可通过的。

2024-12-28 17:55:53 301

原创 LeetCode 242. 有效的字母异位词 (C++实现)

首先定义有26个元素的数组record，全设置为0，首先遍历s字符串，将record中s[i]-'a’位置的元素值加一，然后遍历t字符串，将record中s[i]-'a’位置的元素值减一，如果最后record里面全是0那就说明s和t是字母异位词。给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的。输入: s = “anagram”, t = “nagaram”输入: s = “rat”, t = “car”

2024-12-28 17:33:38 368

原创 LeetCode 142. 环形链表 II (C++实现)

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。首先定义快指针fast和慢指针slow，同时指向头结点，然后让快指针一次移动两个节点，慢指针一次移动一个节点，如果中途相遇，此时记录slow的节点，定义为cur1，然后将head节点定义为cur2。给定一个链表的头节点 head ，返回链表开始入环的第一个节点。解释：链表中有一个环，其尾部连接到第一个节点。

2024-12-28 17:16:03 278

原创 LeetCode 141. 环形链表 (C++实现)

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。首先定义快指针fast和慢指针slow，同时指向头结点，然后让快指针一次移动两个节点，慢指针一次移动一个节点，如果中途相遇就返回true。输入：head = [3,2,0,-4], pos = 1。给你一个链表的头节点 head ，判断链表中是否有环。解释：链表中有一个环，其尾部连接到第一个节点。解释：链表中没有环。

2024-12-28 14:19:02 249

原创 LeetCode 160. 相交链表 (C++实现)

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3。输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。

2024-12-26 21:12:10 529

原创 LeetCode 19. 删除链表的倒数第 N 个结点 (C++实现)

首先定义快指针fast和慢指针slow，先让快指针向前走n+1步，然后再同时移动快慢指针，当快指针指向null的时候，slow->next指向slow->next->next。给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。输入：head = [1,2,3,4,5], n = 2。输入：head = [1,2], n = 1。输入：head = [1], n = 1。输出：[1,2,3,5]

2024-12-26 20:00:25 427

原创 LeetCode 24. 两两交换链表中的节点 (C++实现)

首先定义虚拟头结点dummy，dummy->next 为头结点，然后在定义一个指向虚拟头结点的指针cur，遍历链表，先将cur->next和cur->next->next->next存起来，分别定义指针tmp和tmp1，然后将cur->next指向cur->next->next，cur->next->next指向tmp，cur->next->next->next指向tmp1，然后cur往后移动两个节点，最后返回dummy->next。输入：head = [1,2,3,4]输出：[2,1,4,3]

2024-12-26 19:41:32 585

原创 LeetCode 206. 反转链表 (C++实现)

首先定义两个指针pre和cur，pre指向null，cur指向头结点，然后遍历链表，定义一个中间节点tmp用于存储cur->next，然后cur->next指向pre，然后pre指向cur，cur指向tmp，循环结束返回pre。给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。输入：head = [1,2,3,4,5]输入：head = [1,2]输出：[5,4,3,2,1]输入：head = []

2024-12-24 20:12:13 296

原创 LeetCode 203. 移除链表元素 (C++实现)

首先定义虚拟头结点dummy，dummy->next 为头结点，然后在定义一个指向虚拟头结点的指针cur，遍历链表，如果cur->next的值等于val，则cur->next = cur->next->next，否则cur = cur->next，最后返回动态头结点的下一个节点。输入：head = [1,2,6,3,4,5,6], val = 6。输入：head = [7,7,7,7], val = 7。输入：head = [], val = 1。输出：[1,2,3,4,5]

2024-12-24 19:35:56 480

原创 LeetCode 59. 螺旋矩阵 II (C++实现)

首先定义左指针left、右指针right，上指针top，下指针bottom，然后从1开始循环到n^2，遇到边界的时候指针相应地变化。给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix。输出：[[1,2,3],[8,9,4],[7,6,5]]

2024-12-24 19:15:46 424

原创 LeetCode 54. 螺旋矩阵 (C++实现)

首先定义左指针left、右指针right，上指针top，下指针bottom，然后从左到右，从上到下遍历，遇到边界的时候指针相应地变化。给你一个 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-12-23 20:47:13 486

原创 LeetCode 977. 有序数组的平方 (C++实现)

首先定义左指针left和右指针right，然后定义结果vector，循环比较左指针和右指针指向的值的平方，如果left>=right，则vector从后往前记录，最后当左指针和右指针重合的时候结束循环。解释：平方后，数组变为 [16,1,0,9,100]输入：nums = [-4,-1,0,3,10]输入：nums = [-7,-3,2,3,11]排序后，数组变为 [0,1,9,16,100]输出：[0,1,9,16,100]输出：[4,9,9,49,121]

2024-12-23 19:32:29 293

原创 LeetCode 209. 长度最小的子数组 (C++实现)

首先定义慢指针slow和快指针fast，遍历数组元素，先移动快指针，如果快指针和慢指针中间的元素和大于等于target，记录长度，移动慢指针，遍历完成之后选取最小长度返回。, numsr-1, numsr] ，并返回其长度。输入：target = 11, nums = [1,1,1,1,1,1,1,1]输入：target = 7, nums = [2,3,1,2,4,3]输入：target = 4, nums = [1,4,4]解释：子数组 [4,3] 是该条件下的长度最小的子数组。

2024-12-23 19:11:14 546

原创 LeetCode 844. 比较含退格的字符串 (C++实现)

分别处理s和t，以s举例，首先定义慢指针slow和快指针fast，遍历字符串元素，如果快指针指向的当前元素不等于#，则将快指针指向位置的值赋给慢指针指向的位置，慢指针向后移动一位，否则继续移动快指针，不赋值，如果快指针指向的当前元素等于#，这时候判断slow指针是否在字符串的起始位置，不是的话减1。输入：s = “ab#c”, t = “ad#c”输入：s = “ab##”, t = “c#d#”解释：s 会变成 “c”，但 t 仍然是 “b”。输入：s = “a#c”, t = “b”

2024-12-19 20:21:39 359

原创 LeetCode 283. 移动零 (C++实现)

首先定义慢指针slow和快指针fast，遍历数组元素，如果快指针指向的当前元素不等于0，则将快指针指向位置的值赋给慢指针指向的位置，慢指针向后移动一位，否则继续移动快指针，不赋值。循环结束后将慢指针后面的元素都变为0即可。给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。请注意，必须在不复制数组的情况下原地对数组进行操作。输入: nums = [0,1,0,3,12]输出: [1,3,12,0,0]输入: nums = [0]

2024-12-19 19:31:32 344

原创 LeetCode 26. 删除有序数组中的重复项 (C++实现)

首先定义慢指针slow和快指针fast，遍历数组元素，如果快指针指向的当前元素不等于前一个元素，则先将慢指针向后移动一位，再将快指针指向位置的值赋给慢指针指向的位置，否则继续移动快指针，不赋值。给你一个非严格递增排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。解释：函数应该返回新的长度 5 ，并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。输入：nums = [0,0,1,1,1,2,2,3,3,4]

2024-12-19 19:10:24 329

原创 LeetCode 27. 移除元素 (C++实现)

元素的顺序可能发生改变。首先定义慢指针slow和快指针fast，遍历数组元素，如果快指针指向的元素不等于val，则将快指针指向位置的值赋给慢指针指向的位置，否则继续移动快指针，不赋值。解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。输入：nums = [0,1,2,2,3,0,4,2], val = 2。输入：nums = [3,2,2,3], val = 3。输出：5, nums = [0,1,4,0,3,输出：2, nums = [2,2,

2024-12-18 19:38:42 264

原创 LeetCode 367. 有效的完全平方数 (C++实现)

首先定义左指针left和右指针right(为num)，开始循环，然后取数组中间元素值的平方和x比较，如果中间元素值的平方大于x，则右指针指向中间元素前一个元素，如果中间元素值的平方小于x，则左指针指向中间元素后一个元素，如果中间元素值的平方等于x，返回true。如果 num 是一个完全平方数，则返回 true ，否则返回 false。解释：返回 false ，因为 3.742 * 3.742 = 14 但 3.742 不是一个整数。解释：返回 true ，因为 4 * 4 = 16 且 4 是一个整数。

2024-12-18 19:18:59 432

原创 LeetCode 69. x 的平方根 (C++实现)

首先定义左指针left和右指针right(为x)，开始循环，然后取数组中间元素值的平方和x比较，如果中间元素值的平方大于x，则右指针指向中间元素前一个元素，如果中间元素值的平方小于x，则左指针指向中间元素后一个元素，如果中间元素值的平方等于x，返回中间元素。注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。由于返回类型是整数，结果只保留整数部分，小数部分将被舍去。给你一个非负整数 x ，计算并返回 x 的算术平方根。

2024-12-18 19:03:29 641

原创 LeetCode 34. 在排序数组中查找元素的第一个和最后一个位置 (C++实现)

总体步骤分为两步，第一步二分法寻找左边界，第二步二分法寻找右边界，在寻找左边界的过程中，左边界跟着右指针变化而变化；在寻找右边界的过程中，右边界跟着左指针变化而变化。输入：nums = [5,7,7,8,8,10], target = 8。输入：nums = [5,7,7,8,8,10], target = 6。如果数组中不存在目标值 target，返回 [-1, -1]。输入：nums = [], target = 0。输出：[-1,-1]输出：[-1,-1]

2024-12-17 20:09:41 234

原创 LeetCode 35. 搜索插入位置 (C++实现)

首先定义左指针left和右指针right，然后取数组中间元素的值和target比较，如果中间元素的值大于target，则右指针指向中间元素，如果中间元素的值小于target，则左指针指向中间元素，直到中间元素等于target。最后，如果没有找到，则右指针的下一位就是插入的位置。输入: nums = [1,3,5,6], target = 5。输入: nums = [1,3,5,6], target = 2。输入: nums = [1,3,5,6], target = 7。

2024-12-17 19:02:44 520

原创 LeetCode 704. 二分查找 (C++实现)

首先定义左指针left和右指针right，然后取数组中间元素的值和target比较，如果中间元素的值大于target，则右指针指向中间元素，如果中间元素的值小于target，则左指针指向中间元素，直到中间元素等于target。输入: nums = [-1,0,3,5,9,12], target = 9。输入: nums = [-1,0,3,5,9,12], target = 2。解释: 9 出现在 nums 中并且下标为 4。解释: 2 不存在 nums 中因此返回 -1。

2024-12-17 18:45:16 297

原创 LeetCode 104. 二叉树的最大深度 (C++实现)

这道题可以用递归实现，先求当前节点的左子树深度，再求当前节点的右子树深度，然后取这两个深度的最大值再加一就是当前节点的深度。二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。输入：root = [3,9,20,null,null,15,7]给定一个二叉树 root ，返回其最大深度。输入：root = [1,null,2]

2024-12-16 21:05:52 142

原创 LeetCode 20. 有效的括号 (C++实现)

遍历字符串s，如果遇到 ‘(’ 则压入 ‘)’ ，如果遇到 ‘{’ 则压入 ‘}’ ，如果遇到 ‘[’ 则压入 ‘]’；如果遇到 ‘)’ 或者 ‘}’ 或者 ‘]’ ，首先判断此时栈是否为空，如果是返回false，如果不是再判断栈顶元素是否和当前s获取的元素相等，如果不相等返回false。给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。输入：s = “()[]{}”输入：s = “([])”输入：s = “()”输入：s = “(]”

2024-12-16 20:36:49 328

原创 LeetCode 2. 两数相加 (C++实现)

首先定义两个列表，结果链表result和动态链表cur，动态链表cur的作用是更新result的节点。最后进行循环相加，当l1为空且l2为空且flag为0的时候循环结束。给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]输入：l1 = [2,4,3], l2 = [5,6,4]输入：l1 = [0], l2 = [0]输出：[8,9,9,9,0,0,0,1]

2024-12-16 19:40:29 334

原创 LeetCode 1. 两数之和 (C++实现)

这道题可以用哈希表，首先遍历输入的数组元素，如果nums[i]不在哈希表中，则添加键值对，target-nums[i]的结果作为key，i作为value；反之返回i和哈希表中target-nums[i]的value。解释：因为 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-12-15 20:19:52 274

U-Net 城市景观数据集训练好的语义分割模型

肝脏分割数据集和整个项目文件

空空如也