Java算法OJ（13）双指针

目录

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，一经查实，立即删除！

相关文章

SpringBoot分布式定时任务实战：告别重复执行的烦恼

SpringBoot分布式定时任务实战：告别重复执行的烦恼

场景再现&#xff1a;你刚部署完基于SpringBoot的集群服务&#xff0c;凌晨3点突然收到监控告警——优惠券发放量超出预算两倍&#xff01;检查日志发现&#xff0c;两个节点同时执行了定时任务。这种分布式环境下的定时任务难题&#xff0c;该如何彻底解决&#xff1f; 本文将…
阅读更多...
MySQL 设置允许远程连接完整指南：安全与效率并重

MySQL 设置允许远程连接完整指南：安全与效率并重

一、为什么需要远程连接MySQL&#xff1f; 在分布式系统架构中&#xff0c;应用程序与数据库往往部署在不同服务器。例如&#xff1a; Web服务器&#xff08;如NginxPHP&#xff09;需要连接独立的MySQL数据库数据分析师通过BI工具直连生产库多服务器集群间的数据同步 但直接…
阅读更多...
系统架构书单推荐（一）领域驱动设计与面向对象

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

本文主要是个人在学习过程中所涉猎的一些经典书籍&#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;变量、中…
阅读更多...
考研课程安排（自用）

考研课程安排（自用）

文章目录 408数据结构&#xff08;王道&#xff09;计算机组成原理&#xff08;王道&#xff09;操作系统&#xff08;王道&#xff09;计算机网络&#xff08;湖科大版&#xff09; 数学一高等数学&#xff08;微积分&#xff09;线性代数和概率论 408 数据结构&#xff08;王…
阅读更多...
ultraiso制作u盘启动

ultraiso制作u盘启动

UltraISO制作U盘启动盘的方法 UltraISO是一款功能强大的工具&#xff0c;可以帮助用户将ISO镜像文件写入U盘&#xff0c;从而制作成可启动的系统安装盘。以下是详细的步骤和注意事项&#xff1a; 1. ‌准备工作‌ ‌硬件准备‌&#xff1a;一个容量至少为8GB的U盘&#xff0…
阅读更多...
C语言-发布订阅模式详解与实践

C语言-发布订阅模式详解与实践

文章目录 C语言发布订阅模式详解与实践1. 什么是发布订阅模式&#xff1f;2. 为什么需要发布订阅模式&#xff1f;3. 实际应用场景4. 代码实现4.1 UML 关系图4.2 头文件 (pubsub.h)4.3 实现文件 (pubsub.c)4.4 使用示例 (main.c) 5. 代码分析5.1 关键设计点5.2 实现特点 6. 编译…
阅读更多...
蓝桥杯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;将小…
阅读更多...
第十六章:Specialization and Overloading_《C++ Templates》notes

第十六章:Specialization and Overloading_《C++ Templates》notes

Specialization and Overloading 一、模板特化与重载的核心概念二、代码实战与测试用例三、关键知识点总结四、进阶技巧五、实践建议多选题设计题代码测试说明 一、模板特化与重载的核心概念 函数模板重载 (Function Template Overloading) // 基础模板 template<typename…
阅读更多...
多协议兼容+高并发处理：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 …
阅读更多...
【聊聊层次式架构设计：像搭乐高一样构建软件大厦】

【聊聊层次式架构设计：像搭乐高一样构建软件大厦】

文章目录 聊聊层次式架构设计&#xff1a;像搭乐高一样构建软件大厦理论篇&#xff1a;层次式架构的“千层套路”最底层&#xff1a;基础设施层——默默付出的“基石侠”数据访问层&#xff1a;“数据快递员”业务逻辑层&#xff1a;智慧的“大脑中枢”表示层&#xff1a;软件的…
阅读更多...
最新文章

Copyright @ 2022~2023