温州网站建设 seo/天眼查询个人信息

温州网站建设 seo,天眼查询个人信息,辛集做网站公司,手机上可以编程的app目录 1.前言 2.正文 2.1快乐数 2.2盛最多水的容器 2.3有效的三角形的个数 2.4和为s的两个数 2.5三数之和 2.6四数之和 3.小结 1.前言 哈喽大家好吖，今天继续加练算法题目，一共六道双指针，希望能对大家有所帮助，废话不多…

目录

1.前言

2.正文

2.1快乐数

2.2盛最多水的容器

2.3有效的三角形的个数

2.4和为s的两个数

2.5三数之和

2.6四数之和

3.小结

1.前言

哈喽大家好吖，今天继续加练算法题目，一共六道双指针，希望能对大家有所帮助，废话不多说让我们开始吧。

2.正文

2.1快乐数

202. 快乐数 - 力扣（LeetCode）https://leetcode.cn/problems/happy-number/description/

方法一：

public int happy(int n){int res = 0;while(n != 0){res += (n % 10) * (n % 10);n /= 10;}return res;}public boolean isHappy(int n) {HashSet <Integer> set = new HashSet<>();int ans = n;while(true){ans = happy(ans);if(ans == 1){return true;}if(set.contains(ans)){return false;}set.add(ans);}}

代码分析

  1. happy 方法：

    • 该方法的作用是计算一个整数 n 的每个数字的平方和。

    • 通过 n % 10 获取 n 的最后一位数字，然后将其平方并累加到 res 中。

    • 通过 n /= 10 去掉 n 的最后一位数字。

    • 循环直到 n 变为 0，最后返回 res。

  2. isHappy 方法：

    • 该方法用于判断一个整数 n 是否为快乐数。

    • 使用一个 HashSet 来记录已经出现过的数字，用于检测是否进入了循环。

    • 通过 happy 方法计算 n 的平方和，并将结果存储在 ans 中。

    • 如果 ans 等于 1，说明 n 是快乐数，返回 true。

    • 如果 ans 已经存在于 HashSet 中，说明进入了循环，返回 false。

    • 否则，将 ans 添加到 HashSet 中，并继续循环。

核心思路总结

  • 计算平方和：通过 happy 方法计算一个数的每个数字的平方和。

  • 检测循环：通过 HashSet 记录已经出现过的数字，如果某个数字重复出现，说明进入了循环，该数不是快乐数。

  • 终止条件：如果平方和最终为 1，则该数是快乐数。

 方法二：

public int bitSquareSum(int n) {int sum = 0;while(n > 0){int bit = n % 10;sum += bit * bit;n = n / 10;}return sum;}public boolean isHappy(int n) {int slow = n, fast = n;do{slow = bitSquareSum(slow);fast = bitSquareSum(fast);fast = bitSquareSum(fast);}while(slow != fast);return slow == 1;}

 代码分析

  1. bitSquareSum 方法：

    • 该方法的作用是计算一个整数 n 的每个数字的平方和。

    • 通过 n % 10 获取 n 的最后一位数字，然后将其平方并累加到 sum 中。

    • 通过 n /= 10 去掉 n 的最后一位数字。

    • 循环直到 n 变为 0，最后返回 sum。

  2. isHappy 方法：

    • 该方法用于判断一个整数 n 是否为快乐数。

    • 使用快慢指针的思想：

      • slow 和 fast 初始都指向 n。

      • slow 每次调用一次 bitSquareSum，相当于每次走一步。

      • fast 每次调用两次 bitSquareSum，相当于每次走两步。

    • 如果 slow 和 fast 相遇（即 slow == fast），说明存在循环。

    • 如果相遇时的值为 1，说明是快乐数；否则，不是快乐数。

核心思路总结

  1. 计算平方和：

    • 通过 bitSquareSum 方法计算一个数的每个数字的平方和。

  2. 快慢指针检测循环：

    • 使用快慢指针的思想来检测是否进入了循环。

    • 如果快慢指针相遇，说明存在循环。

    • 如果相遇时的值为 1，说明是快乐数；否则，不是快乐数。

  3. 空间优化：

    • 相比于使用 HashSet 的方法，快慢指针方法不需要额外的空间，空间复杂度为 O(1)。

2.2盛最多水的容器

11. 盛最多水的容器 - 力扣（LeetCode）https://leetcode.cn/problems/container-with-most-water/description/

方法一：

public int maxArea(int[] height) {int i = 0,j = height.length - 1;int area = 0;while(i != j){area = Math.max(area(i,j,height),area);if((height[j] - height[i]) <= 0)j--;else i++;}return area;}public int area(int a,int b,int[] height){return Math.min(height[a],height[b]) * Math.abs(b - a);}

代码分析

  1. area 方法：

    • 该方法的作用是计算两条线之间的容器的面积。

    • 面积的计算公式为：面积 = 两条线的最小高度 * 两条线之间的距离。

    • 使用 Math.min(height[a], height[b]) 获取两条线的最小高度。

    • 使用 Math.abs(b - a) 获取两条线之间的距离。

    • 返回计算得到的面积。

  2. maxArea 方法：

    • 该方法用于找到可以容纳最多水的容器。

    • 使用双指针的方法：

      • 初始化两个指针 i 和 j，分别指向数组的起始位置和末尾位置。

      • 初始化 area 为 0，用于记录当前的最大面积。

    • 在 while 循环中：

      • 计算当前指针 i 和 j 之间的面积，并更新 area 为当前面积和历史最大面积中的较大值。

      • 移动指针：

        • 如果 height[j] <= height[i]，则移动右指针 j--（因为左边的线可能更高，可以尝试找到更高的线）。

        • 否则，移动左指针 i++（因为右边的线可能更高，可以尝试找到更高的线）。

    • 当 i == j 时，循环结束，返回 area。

核心思路总结

  1. 双指针法：

    • 使用两个指针 i 和 j，分别指向数组的起始位置和末尾位置。

    • 通过移动指针来缩小搜索范围，同时计算当前指针之间的面积。

  2. 面积计算：

    • 容器的面积由两条线的最小高度和它们之间的距离决定。

    • 面积公式：面积 = min(height[i], height[j]) * (j - i)。

  3. 指针移动策略：

    • 每次移动高度较小的指针，因为移动高度较大的指针不会增加面积（面积受限于较小的高度）。

    • 通过这种方式，可以逐步缩小搜索范围，同时确保不会错过最大面积。

 方法二：

public int maxArea(int[] height) {int i = 0, j = height.length - 1, res = 0;while(i < j) {res = height[i] < height[j] ?Math.max(res, (j - i) * height[i++]):Math.max(res, (j - i) * height[j--]);}return res;}

代码分析

  1. 初始化：

    • 使用两个指针 i 和 j，分别指向数组的起始位置和末尾位置。

    • 初始化 res 为 0，用于记录当前的最大面积。

  2. 双指针循环：

    • 在 while 循环中，当 i < j 时，执行以下操作：

      • 如果 height[i] < height[j]：

        • 计算当前指针 i 和 j 之间的面积：(j - i) * height[i]。

        • 更新 res 为当前面积和历史最大面积中的较大值。

        • 移动左指针 i++（因为左边的线较短，移动右指针不会增加面积）。

      • 否则：

        • 计算当前指针 i 和 j 之间的面积：(j - i) * height[j]。

        • 更新 res 为当前面积和历史最大面积中的较大值。

        • 移动右指针 j--（因为右边的线较短，移动左指针不会增加面积）。

  3. 返回结果：

    • 当 i >= j 时，循环结束，返回 res。

核心思路总结

  1. 双指针法：

    • 使用两个指针 i 和 j，分别指向数组的起始位置和末尾位置。

    • 通过移动指针来缩小搜索范围，同时计算当前指针之间的面积。

  2. 面积计算：

    • 容器的面积由两条线的最小高度和它们之间的距离决定。

    • 面积公式：面积 = min(height[i], height[j]) * (j - i)。

  3. 指针移动策略：

    • 每次移动高度较小的指针，因为移动高度较大的指针不会增加面积（面积受限于较小的高度）。

    • 通过这种方式，可以逐步缩小搜索范围，同时确保不会错过最大面积。

2.3有效的三角形的个数

611. 有效三角形的个数 - 力扣（LeetCode）https://leetcode.cn/problems/valid-triangle-number/description/

方法一：

public int triangleNumber(int[] nums) {int ans = 0;Arrays.sort(nums);for(int i = 0;i < nums.length;i++){for(int j = i + 1;j < nums.length;j++){int left = j + 1,right = nums.length - 1,k = j;while (left <= right) {int mid = (left + right)/2;if(nums[i] + nums[j] > nums[mid]){k = mid;left = mid + 1;}else{right = mid - 1;}}ans += k - j;}}return ans;}

代码分析

  1. 排序：

    • 首先对数组 nums 进行升序排序。排序的目的是为了方便后续使用双指针或二分查找来优化查找过程。

  2. 双重循环：

    • 使用双重循环遍历数组：

      • 外层循环固定一个数 nums[i]，作为三角形的第一条边。

      • 内层循环固定第二个数 nums[j]，作为三角形的第二条边。

  3. 二分查找：

    • 对于固定的 nums[i] 和 nums[j]，使用二分查找来确定满足 nums[i] + nums[j] > nums[k] 的最大 k。

    • 初始化 left = j + 1 和 right = nums.length - 1，表示搜索范围。

    • 在 while 循环中：

      • 计算中间位置 mid = (left + right) / 2。

      • 如果 nums[i] + nums[j] > nums[mid]，说明 mid 满足条件，尝试向右扩展范围（left = mid + 1）。

      • 否则，向左缩小范围（right = mid - 1）。

    • 最终，k 记录的是满足条件的最大下标。

  4. 统计有效三元组：

    • 对于固定的 nums[i] 和 nums[j]，满足条件的 k 的范围是 [j + 1, k]，共有 k - j 个有效的三元组。

    • 将 k - j 累加到结果 ans 中。

  5. 返回结果：

    • 最终返回 ans，即所有有效三元组的个数。

核心思路总结

  1. 排序：

    • 对数组进行排序，使得后续的查找过程更加高效。

  2. 双重循环 + 二分查找：

    • 外层循环固定第一条边，内层循环固定第二条边。

    • 对于固定的两条边，使用二分查找确定满足条件的第三条边的最大下标。

  3. 三角形判定条件：

    • 对于排序后的数组，如果 nums[i] + nums[j] > nums[k]，则 nums[i] + nums[k] > nums[j] 和 nums[j] + nums[k] > nums[i] 也一定成立（因为数组已排序）。

    • 因此，只需要检查 nums[i] + nums[j] > nums[k] 即可。

  4. 统计有效三元组：

    • 对于固定的 nums[i] 和 nums[j]，满足条件的 k 的范围是 [j + 1, k]，共有 k - j 个有效的三元组。

方法二：

public int triangleNumber(int[] nums) {int ans = 0;Arrays.sort(nums);for(int i = 0;i < nums.length;i++){int k = i + 1;for(int j = i + 1;j <nums.length;j++){while(k + 1 < nums.length && nums[k + 1] < nums[i] + nums[j]){k++;}ans += Math.max(k - j,0);}}return ans;}

代码分析

  1. 排序：

    • 首先对数组 nums 进行升序排序。排序的目的是为了方便后续使用双指针来优化查找过程。

  2. 双重循环：

    • 使用双重循环遍历数组：

      • 外层循环固定一个数 nums[i]，作为三角形的第一条边。

      • 内层循环固定第二个数 nums[j]，作为三角形的第二条边。

  3. 双指针查找：

    • 对于固定的 nums[i] 和 nums[j]，使用双指针的方法来确定满足 nums[i] + nums[j] > nums[k] 的最大 k。

    • 初始化 k = i + 1，表示第三条边的起始位置。

    • 在 while 循环中：

      • 如果 k + 1 < nums.length 且 nums[k + 1] < nums[i] + nums[j]，则移动右指针 k++。

      • 这样，k 会指向满足条件的最大下标。

    • 最终，满足条件的 k 的范围是 [j + 1, k]，共有 k - j 个有效的三元组。

  4. 统计有效三元组：

    • 对于固定的 nums[i] 和 nums[j]，满足条件的 k 的范围是 [j + 1, k]，共有 k - j 个有效的三元组。

    • 将 k - j 累加到结果 ans 中。

  5. 返回结果：

    • 最终返回 ans，即所有有效三元组的个数。

核心思路总结

  1. 排序：

    • 对数组进行排序，使得后续的查找过程更加高效。

  2. 双重循环 + 双指针：

    • 外层循环固定第一条边，内层循环固定第二条边。

    • 对于固定的两条边，使用双指针确定满足条件的第三条边的最大下标。

  3. 三角形判定条件：

    • 对于排序后的数组，如果 nums[i] + nums[j] > nums[k]，则 nums[i] + nums[k] > nums[j] 和 nums[j] + nums[k] > nums[i] 也一定成立（因为数组已排序）。

    • 因此，只需要检查 nums[i] + nums[j] > nums[k] 即可。

  4. 统计有效三元组：

    • 对于固定的 nums[i] 和 nums[j]，满足条件的 k 的范围是 [j + 1, k]，共有 k - j 个有效的三元组。

2.4和为s的两个数

和为S的两个数字__牛客网和为S的两个数字 ,“一战通offer”互联网实习季编程挑战模拟卷 https://www.nowcoder.com/questionTerminal/390da4f7a00f44bea7c2f3d19491311b

public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {ArrayList<Integer> ans = new ArrayList<>();int i = 0,j = array.length - 1;while(i < j){if(array[i] + array[j] == sum){ans.add(array[i]);ans.add(array[j]);return ans;}else if(array[i] + array[j] > sum){j--;}else if(array[i] + array[j] < sum){i++;}}return ans;}

 代码分析

  1. 初始化：

    • 使用一个 ArrayList<Integer> 来存储结果。

    • 使用两个指针 i 和 j，分别指向数组的起始位置和末尾位置。

  2. 双指针查找：

    • 在 while 循环中，当 i < j 时，执行以下操作：

      • 如果 array[i] + array[j] == sum：

        • 将 array[i] 和 array[j] 添加到结果列表 ans 中。

        • 返回结果列表 ans。

      • 如果 array[i] + array[j] > sum：

        • 移动右指针 j--（因为数组是有序的，右边的数较大，移动右指针可以减小和）。

      • 如果 array[i] + array[j] < sum：

        • 移动左指针 i++（因为数组是有序的，左边的数较小，移动左指针可以增大和）。

  3. 返回结果：

    • 如果找到满足条件的两个数，直接返回结果列表。

    • 如果循环结束后仍未找到满足条件的两个数，返回空的 ans。

核心思路总结

  1. 双指针法：

    • 使用两个指针 i 和 j，分别指向数组的起始位置和末尾位置。

    • 通过移动指针来缩小搜索范围，同时计算当前指针指向的两个数的和。

  2. 数组有序性：

    • 数组是有序的，因此可以通过比较 array[i] + array[j] 与 sum 的大小关系来决定移动哪个指针。

    • 如果和大于 sum，移动右指针；如果和小于 sum，移动左指针。

  3. 返回结果：

    • 如果找到满足条件的两个数，直接返回结果。

    • 如果未找到满足条件的两个数，返回空列表。

2.5三数之和

15. 三数之和 - 力扣（LeetCode）https://leetcode.cn/problems/3sum/description/

public List<List<Integer>> threeSum(int[] nums) {List<List<Integer>> list = new ArrayList<>();Arrays.sort(nums);int n = nums.length;for(int i = 0;i < n;i++){if(i > 0 && nums[i - 1] == nums[i]){continue;}int left = i + 1;int right = n - 1;int target = -nums[i];while(left < right){int sum = nums[left] + nums[right];if(sum == target){list.add(Arrays.asList(nums[i],nums[left],nums[right]));left++;right--;while(left < right && nums[left] == nums[left - 1])left++;while(left < right && nums[right] == nums[right + 1])right--;}else if(sum < target){left++;}else{right--;}}}return list;}

 代码分析

  1. 排序：

    • 首先对数组 nums 进行升序排序。排序的目的是为了方便后续使用双指针来优化查找过程，并且可以方便地跳过重复的元素。

  2. 外层循环：

    • 使用一个外层循环遍历数组，固定一个数 nums[i] 作为三元组的第一个数。

    • 如果 nums[i] 与前一个数 nums[i - 1] 相同，则跳过当前循环（避免重复的三元组）。

  3. 双指针查找：

    • 对于固定的 nums[i]，使用双指针的方法在剩余的子数组中查找两个数 nums[left] 和 nums[right]，使得 nums[i] + nums[left] + nums[right] = 0。

    • 初始化 left = i + 1 和 right = n - 1，表示搜索范围。

    • 在 while 循环中：

      • 计算当前的和 sum = nums[left] + nums[right]。

      • 如果 sum == target（即 sum == -nums[i]）：

        • 将 [nums[i], nums[left], nums[right]] 添加到结果列表 list 中。

        • 移动左指针 left++ 和右指针 right--。

        • 跳过重复的 nums[left] 和 nums[right]，避免重复的三元组。

      • 如果 sum < target：

        • 移动左指针 left++（因为数组是有序的，左边的数较小，移动左指针可以增大和）。

      • 如果 sum > target：

        • 移动右指针 right--（因为数组是有序的，右边的数较大，移动右指针可以减小和）。

  4. 返回结果：

    • 最终返回结果列表 list，其中包含所有满足条件的不重复三元组。

核心思路总结

  1. 排序：

    • 对数组进行排序，使得后续的查找过程更加高效，并且可以方便地跳过重复的元素。

  2. 外层循环 + 双指针：

    • 外层循环固定第一个数 nums[i]。

    • 对于固定的 nums[i]，使用双指针在剩余的子数组中查找两个数 nums[left] 和 nums[right]，使得 nums[i] + nums[left] + nums[right] = 0。

  3. 跳过重复元素：

    • 在外层循环中，如果 nums[i] 与前一个数 nums[i - 1] 相同，则跳过当前循环。

    • 在双指针查找过程中，如果 nums[left] 或 nums[right] 与下一个数相同，则跳过重复的数。

  4. 结果存储：

    • 将满足条件的三元组 [nums[i], nums[left], nums[right]] 添加到结果列表 list 中。

2.6四数之和

18. 四数之和 - 力扣（LeetCode）https://leetcode.cn/problems/4sum/description/

 

public List<List<Integer>> fourSum(int[] nums, int target) {List<List<Integer>> ans = new ArrayList<>();Arrays.sort(nums);int n = nums.length;for (int i = 0; i < n - 3; i++) {if (i > 0 && nums[i] == nums[i - 1]) continue;for (int j = i + 1; j < n - 2; j++) {if (j > i + 1 && nums[j] == nums[j - 1]) continue;int l = j + 1, r = n - 1;long aim = (long) target - nums[i] - nums[j];while (l < r) {long sum = (long) nums[l] + nums[r];if (sum == aim) {ans.add(Arrays.asList(nums[i], nums[j], nums[l], nums[r]));l++;r--;while (l < r && nums[l] == nums[l - 1]) l++;while (l < r && nums[r] == nums[r + 1]) r--;} else if (sum < aim) {l++;} else {r--;}}}}return ans;}

 代码分析

  1. 排序：

    • 首先对数组 nums 进行升序排序。排序的目的是为了方便后续使用双指针来优化查找过程，并且可以方便地跳过重复的元素。

  2. 双重循环：

    • 使用双重循环遍历数组：

      • 外层循环固定一个数 nums[i]，作为四元组的第一个数。

      • 内层循环固定第二个数 nums[j]，作为四元组的第二个数。

    • 在每次循环中，如果当前数与前一个数相同，则跳过当前循环（避免重复的四元组）。

  3. 双指针查找：

    • 对于固定的 nums[i] 和 nums[j]，使用双指针的方法在剩余的子数组中查找两个数 nums[l] 和 nums[r]，使得 nums[i] + nums[j] + nums[l] + nums[r] = target。

    • 初始化 l = j + 1 和 r = n - 1，表示搜索范围。

    • 计算目标值 aim = target - nums[i] - nums[j]。

    • 在 while 循环中：

      • 计算当前的和 sum = nums[l] + nums[r]。

      • 如果 sum == aim：

        • 将 [nums[i], nums[j], nums[l], nums[r]] 添加到结果列表 ans 中。

        • 移动左指针 l++ 和右指针 r--。

        • 跳过重复的 nums[l] 和 nums[r]，避免重复的四元组。

      • 如果 sum < aim：

        • 移动左指针 l++（因为数组是有序的，左边的数较小，移动左指针可以增大和）。

      • 如果 sum > aim：

        • 移动右指针 r--（因为数组是有序的，右边的数较大，移动右指针可以减小和）。

  4. 返回结果：

    • 最终返回结果列表 ans，其中包含所有满足条件的不重复四元组。

核心思路总结

  1. 排序：

    • 对数组进行排序，使得后续的查找过程更加高效，并且可以方便地跳过重复的元素。

  2. 双重循环 + 双指针：

    • 外层循环固定第一个数 nums[i]，内层循环固定第二个数 nums[j]。

    • 对于固定的 nums[i] 和 nums[j]，使用双指针在剩余的子数组中查找两个数 nums[l] 和 nums[r]，使得 nums[i] + nums[j] + nums[l] + nums[r] = target。

  3. 跳过重复元素：

    • 在外层循环和内层循环中，如果当前数与前一个数相同，则跳过当前循环。

    • 在双指针查找过程中，如果 nums[l] 或 nums[r] 与下一个数相同，则跳过重复的数。

  4. 结果存储：

    • 将满足条件的四元组 [nums[i], nums[j], nums[l], nums[r]] 添加到结果列表 ans 中。

3.小结

今天的分享到这里就结束了，喜欢的小伙伴点点赞点点关注，你的支持就是对我最大的鼓励，大家加油！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/web/73136.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

系统架构书单推荐（一）领域驱动设计与面向对象

系统架构书单推荐（一）领域驱动设计与面向对象

本文主要是个人在学习过程中所涉猎的一些经典书籍&#xff0c;有些已经阅读完&#xff0c;有些还在阅读中。于我而言&#xff0c;希望追求软件系统设计相关的原则、方法、思想、本质的东西&#xff0c;并希望通过不断的学习、实践和积累&#xff0c;提升自身的知识和认知。希望…
阅读更多...
动态规划-01背包

动态规划-01背包

兜兜转转了半天&#xff0c;发现还是Carl写的好。 看过动态规划-基础的读者&#xff0c;大概都清楚。 动态规划是将大问题&#xff0c;分解成子问题。并将子问题的解储存下来&#xff0c;避免重复计算。 而背包问题&#xff0c;就是动态规划延申出来的一个大类。 而01背包&…
阅读更多...
使用VS2022编译CEF

使用VS2022编译CEF

前提 选择编译的版本 CEF自动编译&#xff0c;在这里可以看到最新的稳定版和Beta版。 从这里得出&#xff0c;最新的稳定版是134.0.6998.118&#xff0c;对应的cef branch是6998。通过这个信息可以在Build requirements查到相关的软件配置信息。 这里主要看Windows下的编译要…
阅读更多...
C++20：玩转 string 的 starts_with 和 ends_with

C++20：玩转 string 的 starts_with 和 ends_with

文章目录 一、背景与动机二、string::starts_with 和 string::ends_with&#xff08;一&#xff09;语法与功能&#xff08;二&#xff09;使用示例1\. 判断字符串开头2\. 判断字符串结尾 &#xff08;三&#xff09;优势 三、string_view::starts_with 和 string_view::ends_w…
阅读更多...
智能飞鸟监测 守护高压线安全

智能飞鸟监测 守护高压线安全

飞鸟检测新纪元&#xff1a;视觉分析技术的革新应用 在现代化社会中&#xff0c;飞鸟检测成为了多个领域不可忽视的重要环节。无论是高压线下的安全监测、工厂内的生产秩序维护&#xff0c;还是农业区的作物保护&#xff0c;飞鸟检测都扮演着至关重要的角色。传统的人工检测方…
阅读更多...
ADC噪声全面分析 -04- 有效噪声带宽简介

ADC噪声全面分析 -04- 有效噪声带宽简介

为什么要了解ENBW&#xff1f; 了解模数转换器 (ADC) 噪声可能具有挑战性&#xff0c;即使对于最有经验的模拟设计人员也是如此。 Delta-sigma ADC 具有量化和热噪声的组合&#xff0c;这取决于 ADC 的分辨率、参考电压和输出数据速率 (ODR)。 在系统级别&#xff0c;额外的信…
阅读更多...
STM32单片机uCOS-Ⅲ系统10 内存管理

STM32单片机uCOS-Ⅲ系统10 内存管理

目录 一、内存管理的基本概念 二、内存管理的运作机制 三、内存管理的应用场景 四、内存管理函数接口讲解 1、内存池创建函数 OSMemCreate() 2、内存申请函数 OSMemGet() 3、内存释放函数 OSMemPut() 五、实现 一、内存管理的基本概念 在计算系统中&#xff0c;变量、中…
阅读更多...
蓝桥杯2023年第十四届省赛真题-异或和之差

蓝桥杯2023年第十四届省赛真题-异或和之差

题目来自DOTCPP&#xff1a; 思路&#xff1a; 什么是异或和&#xff1f; ①题目要求我们选择两个不相交的子段&#xff0c;我们可以枚举一个分界线i&#xff0c;子段1在 i 的左边&#xff0c; 子段2在 i 的右边&#xff0c;分别找到子段1和子段2的最大值、最小值。 ②怎么确…
阅读更多...
Linux作业2——有关文件系统权限的练习

Linux作业2——有关文件系统权限的练习

1、创建/www目录&#xff0c;在/www目录下新建name和https目录&#xff0c;在name和https目录下分别创建一个index.html文件&#xff0c;name下面的index.html文件中包含当前主机的主机名&#xff0c;https目录下的index.html文件中包含当前主机的ip地址。 #创建/www目录&…
阅读更多...
leeCode 70. 爬楼梯

leeCode 70. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢&#xff1f; 示例 1&#xff1a; 输入&#xff1a;n 2 输出&#xff1a;2 解释&#xff1a;有两种方法可以爬到楼顶。 1. 1 阶 1 阶 2. 2 阶 示例 2&#x…
阅读更多...
算法题（105）：小猫爬山

算法题（105）：小猫爬山

审题&#xff1a; 本题需要我们找出将n个小猫放在有限重的缆车上运下山所需的最小缆车数 时间复杂度分析&#xff1a;本题的数据量小于等于18&#xff0c;所以我们在做好剪枝的前提下可以使用深度优先搜索解题 思路&#xff1a; 方法一&#xff1a;dfs 搜索策略&#xff1a;将小…
阅读更多...
多协议兼容+高并发处理：EasyCVR如何破解AI安防规模化落地难题？

多协议兼容+高并发处理：EasyCVR如何破解AI安防规模化落地难题？

随着AI技术在安防领域的深入应用&#xff0c;规模化部署面临两大核心挑战&#xff1a;设备协议碎片化导致的接入壁垒与海量视频流并发带来的性能瓶颈。TSINGSEE青犀视频的EasyCVR平台通过“多协议兼容高并发处理”双引擎驱动&#xff0c;结合云边端协同架构与智能算法优化&…
阅读更多...
IntelliJ IDEA 中 Git 高频问题与操作详解｜新手避坑指南

IntelliJ IDEA 中 Git 高频问题与操作详解｜新手避坑指南

标签&#xff1a;IntelliJ IDEA Git操作, Git教程, 版本控制, 冲突解决, 分支管理 引言 你是否遇到过这些问题&#xff1f; 代码提交后想撤销怎么办&#xff1f;合并分支时冲突不会解决&#xff1f;不小心把错误代码推送到远程仓库&#xff1f; 本文针对 IntelliJ IDEA 中 Git …
阅读更多...
N列股票收盘价为起点的马科维茨（Markowitz）均值—方差理论

N列股票收盘价为起点的马科维茨（Markowitz）均值—方差理论

1. 数据准备与收益率计算 输入数据&#xff1a; 假设你有一个矩阵&#xff0c;每一列代表一只股票的历史收盘价序列。每一行对应一个时间点的收盘价。 计算收益率&#xff1a; 马科维茨理论要求使用资产的收益率而非价格。常用的收益率计算方法有对数收益率或简单收益率。 2.…
阅读更多...
python基于spark的心脏病患分类及可视化(源码+lw+部署文档+讲解)，源码可白嫖!

python基于spark的心脏病患分类及可视化(源码+lw+部署文档+讲解)，源码可白嫖!

摘要 时代在飞速进步&#xff0c;每个行业都在努力发展现在先进技术&#xff0c;通过这些先进的技术来提高自己的水平和优势&#xff0c;汽车数据分析平台当然不能排除在外。本次我所开发的心脏病患分类及可视化系统是在实际应用和软件工程的开发原理之上&#xff0c;运用Pyth…
阅读更多...
3.milvus索引-HNSW

3.milvus索引-HNSW

索引作用 加速大型数据集上的查询。 向量字段&#xff0c;仅只能创建一个索引。 milvus支持的向量索引类型大部分使用 近似最近邻搜索算法。ANNS该算法的核心不局限于返回最准确的结果&#xff0c;而是仅搜索目标的邻居。ANNS通过在可接受的范围内牺牲准确性提高检索效率。 …
阅读更多...
Python（学习二）

Python（学习二）

列表&#xff1a;[] 列表是可以容纳不同类型的数据的 列表取&#xff1a; 列表切片&#xff1a;一次去获取多个元素 第三个参数&#xff0c;设置跨度值&#xff1a; 列表倒序输出 列表增&#xff1a; 列表后面添加元素&#xff1a; 切片&#xff1a;实现添加元素 任意位置…
阅读更多...
【中文翻译】第1章-The Algorithmic Foundations of Differential Privacy

【中文翻译】第1章-The Algorithmic Foundations of Differential Privacy

为方便阅读&#xff0c;故将《The Algorithmic Foundations of Differential Privacy》翻译项目内容搬运至此&#xff1b; 教材原文地址&#xff1a;https://www.cis.upenn.edu/~aaroth/Papers/privacybook.pdf 中文翻译版 Github 项目地址1&#xff1a;https://github.com/gu…
阅读更多...
Web开发-JS应用NodeJS原型链污染文件系统Express模块数据库通讯

Web开发-JS应用NodeJS原型链污染文件系统Express模块数据库通讯

知识点&#xff1a; 1、安全开发-NodeJS-开发环境&功能实现 2、安全开发-NodeJS-安全漏洞&案例分析 3、安全开发-NodeJS-特有漏洞 node.js就是专门运行javascript的一个应用程序&#xff0c;区别于以往用浏览器解析原生js代码&#xff0c;node.js本身就可以解析执行js代…
阅读更多...
Flutter使用自签证书打包ipa

Flutter使用自签证书打包ipa

在 Flutter 中使用自签证书打包 IPA 文件&#xff0c;可以通过以下步骤完成&#xff1a; 1. 准备自签证书 方式一 生成自签证书&#xff1a; 打开 钥匙串访问 应用。选择 证书助理 > 创建证书。按照提示填写证书信息&#xff0c;选择证书类型为 代码签名&#xff0c;并保存…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023