专题【二分查找】刷题日记

题目列表

4. 寻找两个正序数组的中位数
33. 搜索旋转排序数组
34. 在排序数组中查找元素的第一个和最后一个位置
35. 搜索插入位置
69. x 的平方根
167. 两数之和 II - 输入有序数组
209. 长度最小的子数组
222. 完全二叉树的节点个数
287. 寻找重复数

2023.04.14

4. 寻找两个正序数组的中位数

题目

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

提示：

  • nums1.length == m
  • nums2.length == n
  • 0 <= m <= 1000
  • 0 <= n <= 1000
  • 1 <= m + n <= 2000
  • -106 <= nums1[i], nums2[i] <= 106

思路

  1. 总元素个数如果是奇数
  2. 每一个数组都找中间的指针
  3. 如果对于这俩指针， 左右恰巧数量一样，就返回这俩指针对应的元素（奇数返回小的，偶数返回两个的平均）
  4. a[0], …, a[i],…a[m-1]，b[0],…,b[j],…b[n-1]，左右一样指a[0]…a[i]元素个数加上b[0]…b[j]元素个数和剩余部分一致，并且a[i-1]<b[j]<a[i+1] && b[j-1] < a[i] < b[j+1]，即a[i]的坐边小于b[j]、b[j]的左边小于a[i]、a[i]的右边大于b[j]、b[j]的右边大于a[i]
  5. 否则使用二分查找其中一个，同时调整另一个元素的个数，始终保持，左右元素相等，直到满足上述第二个条件

答案

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;

        if (m > n) {
        	// 从短的做遍历。为了避免处理nums2的边界
            return findMedianSortedArrays(nums2, nums1);
        }
        int halfNum = (m + n + 1) / 2;

        int left = 0, right = m;
        int leftMax = 0, rightMin = 0;

        while (left <= right) {
        	// 防溢出
            int middle1 = left + (right - left) / 2;
            int middle2 = halfNum - middle1;
			
			// i_1要处理左溢出即==0的判断，i本身要处理右溢出即==m
			// MAX_VALUE还是MIN_VALUE是从max还是min赋值的，反正就是取合法的那边
            int ai_1 = middle1 == 0 ? Integer.MIN_VALUE : nums1[middle1 - 1];
            int ai = middle1 == m ? Integer.MAX_VALUE : nums1[middle1];
	
            int bj_1 = middle2 == 0 ? Integer.MIN_VALUE : nums2[middle2 - 1];
            int bj = middle2 == n ? Integer.MAX_VALUE : nums2[middle2];

			// 满足条件就记录
            if (ai_1 <= bj) {
                leftMax = Math.max(ai_1, bj_1);
                rightMin = Math.min(ai, bj);
                left = middle1 + 1;
            } else {
                right = middle1 - 1;
            }

        }
        // 满足条件才更新，所以直接返回
        return ((m + n) % 2 == 0) ? (leftMax + rightMin) / 2.0 : leftMax;

    }
}

33. 搜索旋转排序数组

题目

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4

示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1

示例 3：

输入：nums = [1], target = 0
输出：-1

提示：

  • 1 <= nums.length <= 5000
  • -104 <= nums[i] <= 104
  • nums 中的每个值都 独一无二
  • 题目数据保证 nums 在预先未知的某个下标上进行了旋转
  • -104 <= target <= 104

思路

核心是找到在哪边搜索

  1. 先判断哪边是有序的
  2. 如果目标值在有序的这边，就在这边，否则在另一边

答案

class Solution {
    public int search(int[] nums, int target) {
        return search(nums, target, 0, nums.length - 1);
    }

    public int search(int[] nums, int target, int left, int right) {
    	// 递归的边界
        if (left > right) {
            return -1;
        }

        int middle = left + (right - left) / 2;
        int value = nums[middle];
        // 递归的终止条件
        if (value == target) {
            return middle;
        } 
        // 左边有序
        if (nums[left] <= value) {
        	// 因为左边有序，所以判断在不在左边范围内，在的话就在左边
            if (target < value && nums[left] <= target) {
                return search(nums, target, left, middle - 1);
            } else {
                return search(nums, target, middle + 1, right);
            }
        } else {
        	// 右边同理
            if (target > value && target <= nums[right]) {
                return search(nums, target, middle + 1, right);
            } else {
                return search(nums, target, left, middle - 1);
            }
        }
    }
}

34. 在排序数组中查找元素的第一个和最后一个位置

题目

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

提示：

  • 0 <= nums.length <= 105
  • -109 <= nums[i] <= 109
  • nums 是一个非递减数组
  • -109 <= target <= 109

思路

和普通二分的区别是搜索到之后的动作

  1. 搜索最左边的话，就一直把右边界往左边移动。
  2. 右边同理，详见注释

答案

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if (nums.length == 0) {
            return new int[] { -1, -1 };
        }
        return new int[] { lBsearch(nums, target, 0, nums.length - 1), rBsearch(nums, target, 0, nums.length - 1) };
    }

    public int lBsearch(int[] nums, int target, int left, int right) {
		// 因为左右都是闭区间，所以相等
        while (left <= right) {
            int middle = left + (right - left) / 2;
            int value = nums[middle];
            if (value < target) {
                left = middle + 1;
            } else {
            	// 相等就移动右边界
                right = middle - 1;
            }
        }
        // 考虑剩两个元素的时候，[m, target]，这时候middle==left, m < target，最后右移一步。所以最后，如果有left一定指向元素
        // 考虑剩两个元素的时候，[target, target]，这时候middle==left, 最后左移一步。所以最后，如果有left一定指向元素
        // 一些边界判断
        return left >= 0 && left < nums.length && nums[left] == target ? left : -1;
    }

	// 同搜索左边界
    public int rBsearch(int[] nums, int target, int left, int right) {
        while (left <= right) {
            int middle = left + (right - left) / 2;
            int value = nums[middle];
            if (value <= target) {
                left = middle + 1;
            } else {
                right = middle - 1;
            }
        }
        return right >= 0 && right < nums.length && nums[right] == target ? right : -1;
    }
}

2024.04.19

35. 搜索插入位置

题目

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4

提示:

  • 1 <= nums.length <= 104
  • -104 <= nums[i] <= 104
  • nums 为 无重复元素 的 升序 排列数组
  • -104 <= target <= 104

思路

比二分查找，要多考虑下，最后left和right的位置关系
考虑两个元素的时候[m, n], m < target < n, nums[middle] = m < target，移动right，left和right重合在m，最后一次，right-1，left不动

答案

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        // 闭区间，所以=
        while (left <= right) {
            int middle = left + (right - left) / 2;
            int value = nums[middle];

            if (value == target) {
                return middle;
            } else if (value < target) {
                left = middle + 1;
            } else {
                right = middle - 1;
            }
        }
        return left;
    }
}

69. x 的平方根

题目

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：

输入：x = 4
输出：2

示例 2：

输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。

提示：

  • 0 <= x <= 2^31 - 1

思路

0-x一半一半逼近，因为1 = 1 x 1, 所以x是闭区间

答案

class Solution {
    public int mySqrt(int x) {
    	// 边界0,1
        if (x < 2) {
            return x;
        }
        int left = 0, right = x;

        while (left <= right) {
            int middle = left + (right - left) / 2;
            if (x / middle == middle) {
                return middle;
            } else if (x / middle < middle) {
                right = middle - 1;
            } else {
                left = middle + 1;
            }
        }
        // 2.8取2，所以-1
        return left - 1;
    }
}

167. 两数之和 II - 输入有序数组

题目

给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列 ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

示例 2：

输入：numbers = [2,3,4], target = 6
输出：[1,3]
解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。

示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]
解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

提示：

  • 2 <= numbers.length <= 3 * 104
  • -1000 <= numbers[i] <= 1000
  • numbers 按 非递减顺序 排列
  • -1000 <= target <= 1000
  • 仅存在一个有效答案

思路

因为有序，固定一个，另一个用二分

答案

// 二分，O（n log(n)）
class Solution {
    public int[] twoSum(int[] numbers, int target) {
        for (int i = 0; i < numbers.length; i++) {
            int current = numbers[i];
            int left = i + 1;
            int right = numbers.length - 1;
            while (left <= right) {
                int middle = left + (right - left) / 2;
                if (current + numbers[middle] == target) {
                    return new int[] { i + 1, middle + 1 };
                } else if (current + numbers[middle] < target) {
                    left = middle + 1;
                } else {
                    right = middle - 1;
                }
            }
        }
        return new int[] { -1, -1 };
    }
}
// 双指针 O(n)
class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int left = 0, right = numbers.length - 1;
        while (left < right) {
            int leftValue = numbers[left];
            int rightValue = numbers[right];
            if (leftValue + rightValue == target) {
                return new int[] { left + 1, right + 1 };
            } else if (leftValue + rightValue < target) {
                left++;
            } else {
                right--;
            }
        }
        return new int[] { -1, -1 };
    }
}

209. 长度最小的子数组

题目

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 连续
子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

提示：

  • 1 <= target <= 109
  • 1 <= nums.length <= 105
  • 1 <= nums[i] <= 105

进阶：

  • 如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。

思路

  1. 滑动窗口
  2. 前缀和+二分搜索。二分一定要有序，前缀和可以做到

答案

// 滑动窗口
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int result = Integer.MAX_VALUE;
        int left = 0, right = 0;
        int sum = 0;
        while (right < nums.length) {
            sum += nums[right];

            while (sum >= target && left <= right) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];
            }
            right++;

        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}
// 前缀和+二分
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int[] sums = new int[nums.length + 1];
        int sum = 0;
        for (int i = 1; i < sums.length; i++) {
            sum += nums[i - 1];
            sums[i] = sum;
        }

        int result = Integer.MAX_VALUE;
        for (int i = 0; i < sums.length; i++) {
            int current = sums[i];
            int left = i + 1, right = sums.length - 1;
            while (left <= right) {
                int middle = left + (right - left) / 2;
                int value = sums[middle];
                if (value - current >= target) {
                    result = Math.min(result, middle - i);
                    right = middle - 1;
                } else {
                    left = middle + 1;
                }
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

222. 完全二叉树的节点个数

题目

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

示例 1：
在这里插入图片描述

输入：root = [1,2,3,4,5,6]
输出：6

示例 2：

输入：root = []
输出：0

示例 3：

输入：root = [1]
输出：1

提示：

  • 树中节点的数目范围是[0, 5 * 104]
  • 0 <= Node.val <= 5 * 104
  • 题目数据保证输入的树是 完全二叉树

进阶： 遍历树来统计节点是一种时间复杂度为 O(n) 的简单解决方案。你可以设计一个更快的算法吗？

思路

  1. 因为是完全二叉树
  2. 求左右树的高度，如果相等，则说明左子树是完全二叉树，左子树元素个数是2左子树的高度-1，再加上根节点，就是2左子树的高度
  3. 如果不相等，说明右子树是完全二叉树，算法同2

答案

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int countNodes(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int left = high(root.left);
        int right = high(root.right);

        if (left == right) {
        	// 左子树是完全二叉树，左子树加右边的数量
            return countNodes(root.right) + (1 << left);
        } else {
        	// 右子树是完全二叉树，右子树加左边的数量
            return countNodes(root.left) + (1 << right);
        }
    }

    public int high(TreeNode root) {
        int result = 0;
        while (root != null) {
            result++;
            root = root.left;
        }
        return result;
    }
}

287. 寻找重复数

题目

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。
假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。
你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。

示例 1：

输入：nums = [1,3,4,2,2]
输出：2

示例 2：

输入：nums = [3,1,3,4,2]
输出：3

示例 3 :

输入：nums = [3,3,3,3,3]
输出：3

提示：

  • 1 <= n <= 105
  • nums.length == n + 1
  • 1 <= nums[i] <= n
  • nums 中 只有一个整数 出现 两次或多次 ，其余整数均只出现 一次

进阶：

  • 如何证明 nums 中至少存在一个重复的数字?
  • 你可以设计一个线性级时间复杂度 O(n) 的解决方案吗？

思路

之前双指针有过，这次换个思路
要二分，必须有单调数组，有点像定义DP数组了、本次定义cnt[i]表示小于等于i的元素数量，有点像前缀和的逻辑，记住吧。数组构造单调数组有两个办法：前缀和、cnt[i]
如果数组中只有一个重复元素，根据题意 nums.length == n + 1 、1 <= nums[i] <= n，其实必然重复（n+1个位置，只有n个元素）。则重复元素之前，cnt[i] == i，[1,2,3,4,5,6,5,7,8]，这种cnt[0-4] = [0-4]，因为可能重复多个，所以cnt[i] <= i
用二分找到这个就行了，就是哪个位置开始出现不小于等于

答案

class Solution {
    public int findDuplicate(int[] nums) {
        int left = 0, right = nums.length - 1;
        int result = 0;
        // 找数，数在0-n之间（根据题意nums.length==n+1），搜索的是小于等于xxx
        while (left <= right) {
        	// 二分找数
            int middle = left + (right - left) / 2;
            // 计算cnt
            int cnt = 0;
            for (int i = 0; i < nums.length; i++) {
            	// 遍历数组，小于等于middle的数个数
                if (nums[i] <= middle) {
                    cnt++;
                }
            }
            // 是不是满足条件，满足说明数小了
            if (cnt <= middle) {
                left = middle + 1;
            } else {
            	// 记录下，因为可能是大于target的，所以继续搜索
            	// [1,2,3,4,5,6,5,7,8]，cnt[6] = 7, cnt[5] = 6, cnt[8] = 8，都满足条件，所以继续搜索
                result = middle;
                right = middle - 1;
            }
        }
        return result;
    }
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

列表控件列表表格树

列表控件列表表格树

QListWidget QListWidget 是 Qt 框架中的一个部件&#xff0c;用于在图形用户界面中显示一个列表。这个列表可以包含文本项、图标或者其他自定义的部件。它非常适合用于呈现一系列可选择的元素。 基本属性和设置 NoSelection&#xff1a;不允许选择。用户无法选择任何项。 S…
阅读更多...
项目风险管理

项目风险管理

风险&#xff0c;简单来说&#xff0c;就是在特定环境下、特定时间段内&#xff0c;某种损失发生的可能性。它是客观存在的&#xff0c;不以人的意志为转移&#xff0c;具有损失性、不确定性、普遍性、社会性等特点。风险的特点可以用几个“不知道”来概括&#xff1a;不知道什…
阅读更多...
suse15 系统分区信息损坏修复案例一则

suse15 系统分区信息损坏修复案例一则

关键词 suse linux、系统分区fdisk、分区类型testdisk、grub2、bios There are many things that can not be broken&#xff01; 如果觉得本文对你有帮助&#xff0c;欢迎点赞、收藏、评论&#xff01; 一、问题现象 业务反馈一台suse服务器&#xff0c;因错误执行了fdisk分区…
阅读更多...
【Hadoop3.3.6全分布式环境搭建】

【Hadoop3.3.6全分布式环境搭建】

说明： 完成Hadoop全分布式环境搭建，需准备至少3台虚拟机（master slave01 slave02）环境： VMWare + Centos7 + JDK1.8+ Hadoop3.3.6主机规划： 主节点：master从节点：slave01 , slave02 一、准备工作 1、所有主机安装jdk 上传jdk-8u171-linux-x64.tar.gz到/root目录下，然后…
阅读更多...
OJ：数字三角形（搜索）

OJ：数字三角形（搜索）

&#x1f381;个人主页&#xff1a;我们的五年 &#x1f50d;系列专栏&#xff1a;每日一练 &#x1f337;追光的人&#xff0c;终会万丈光芒 &#x1f337;1.问题描述&#xff1a; ⛳️题目描述&#xff1a; 示出了一个数字三角形。 请编一个程序计算从顶至底的某处的一条路…
阅读更多...
声明式 GUI 工具包：响应式、跨平台、多语言 | 开源日报 No.230

声明式 GUI 工具包：响应式、跨平台、多语言 | 开源日报 No.230

slint-ui/slint Stars: 14.5k License: NOASSERTION slint 是一个声明式的 GUI 工具包&#xff0c;用于为 Rust、C 或 JavaScript 应用程序构建原生用户界面。 可扩展性&#xff1a;支持响应式 UI 设计&#xff0c;跨操作系统和处理器架构的跨平台使用&#xff0c;并支持多种…
阅读更多...
Linux 服务器硬件及RAID配置实战

Linux 服务器硬件及RAID配置实战

服务器详解 服务器分类 可以分为&#xff1a;塔式服务器、机架服务器、刀片服务器、机柜服务器等。 其中以机架式居多 服务器架构 服务器品牌&#xff1a; 戴尔、AMD、英特尔、惠普、华为、华3&#xff08;H3C&#xff09;、联想、浪潮、长城 服务器规格&#xff1a; 规格…
阅读更多...
*Linux系统的进程和计划任务管理

*Linux系统的进程和计划任务管理

目录 一、查看进程 1、程序和进程的关系 *2、ps查看静态进程信息 1&#xff09;ps aux 2&#xff09;ps -elf *3、top查看动态进程信息 4、pgrep查看进程信息 5、pstree查看进程树 二、控制进程 1、进程启动方式 2、进程的前后台调度 3、终止进程的运行 三、计划任…
阅读更多...
SQLite R*Tree 模块（三十三）

SQLite R*Tree 模块（三十三）

返回&#xff1a;SQLite—系列文章目录 上一篇&#xff1a;SQLite FTS3 和 FTS4 扩展(三十二) 下一篇:SQLite轻量级会话扩展&#xff08;三十四&#xff09; 1. 概述 R-Tree 是一个特殊的 专为执行范围查询而设计的索引。R-树最常见的是 用于地理空间系统&#xff0c;其中…
阅读更多...
[论文阅读链接]

[论文阅读链接]

CVPR2023&#xff1a;Learning Human-to-Robot Handovers from Point Clouds http://t.csdnimg.cn/OfSnShttp://t.csdnimg.cn/OfSnS仿真工具&#xff1a;dm_control: Software and Tasks for Continuous Control dm_control 翻译: Software and Tasks for Continuous Control…
阅读更多...
Idea中使用Git详细教学

Idea中使用Git详细教学

目录 一、配置 Git 二、创建项目远程仓库 三、初始化本地仓库 方法一&#xff1a; 方法二&#xff1a; 四、连接远程仓库 五、提交与拉取到本地仓库 六、推送到远程仓库 七、克隆远程仓库到本地 方法一&#xff1a; 方法二&#xff1a; 八、Git分支操作 一、配置 G…
阅读更多...
嵌入式学习57-ARM7(字符设备驱动框架led)

嵌入式学习57-ARM7(字符设备驱动框架led)

知识零碎&#xff1a; kernel 内核 printk 内核打印 cat /proc/devices mknod ? 查看指令 gcc -oapp hello.c 字符设备驱动流程 字符设备程序运行流程 gcc中-c和-o是编译时可选的参数 -c …
阅读更多...
使用python-can和cantools实现arxml报文解析、发送和接收的完整指南

使用python-can和cantools实现arxml报文解析、发送和接收的完整指南

文章目录 背景一、硬件支持二、环境准备1、python解释器安装2、python库安装 三、 收发案例四、 方法拓展1、canoe硬件调用2、回调函数介绍 结论 背景 在汽车行业中&#xff0c;CAN (Controller Area Network) 总线是用于车辆内部通信的关键技术。arxml文件是一种用于描述CAN消…
阅读更多...
linux下摄像头设置固定的设备名

linux下摄像头设置固定的设备名

目录 2.热插拔udev机制 3.设置udev的规则 1.查看usb ID 2. 查看usb设备的信息 3.编译规则 4.拓展 1.问题的出现 通过我之前的文章配置完摄像头的开机自启动之后我们会发现有的时候会出现启动不了的情况&#xff0c;通过实验我发现是摄像头的设备名发生了改变&#xff0c;…
阅读更多...
网络安全产品---态势感知EDR

网络安全产品---态势感知EDR

态势感知 what SA&#xff0c;Situational Awareness 是对一定时间和空间内的环境元素进行感知&#xff0c;并对这些元素的含义进行理解&#xff0c;最终预测这些元素在未来的发展状态。 why 安全防护思想已经从过去的被动防御向主动防护和智能防护转变。如果不做到主动防御…
阅读更多...
【JS】js数字转k、w结尾 | 1000 = 1k

【JS】js数字转k、w结尾 | 1000 = 1k

问题 数字转k、w结尾 如&#xff1a;10001k 100001w 码 /*** 数字转k,w* param {Number} num * returns String*/ const numberTokw num > {if (num < 1000) return numlet endStr w,numVal 10000;if (num > 999 && num < 10000) {endStr knumVal …
阅读更多...
嵌入式物联网实战开发笔记-乐鑫ESP32芯片功能对比以及功能选型【doc.yotill.com】

嵌入式物联网实战开发笔记-乐鑫ESP32芯片功能对比以及功能选型【doc.yotill.com】

乐鑫ESP32入门到精通项目开发参考百例下载&#xff1a; 链接&#xff1a;https://pan.baidu.com/s/1ATvRnAZvxkev-PJfd3EAPg?pwd4e33 提取码&#xff1a;4e33 2.1 初识 ESP32 ESP32-S3 是一款低功耗的 MCU 系统级芯片 (SoC)&#xff0c;支持 2.4 GHz Wi-Fi 和低功耗蓝牙 (…
阅读更多...
minio如何配置防盗链

minio如何配置防盗链

MinIO 是一个开源的对象存储服务器&#xff0c;用于存储大量的数据&#xff0c;同时提供了丰富的功能和 API。配置防盗链可以帮助你控制谁可以访问存储在 MinIO 上的对象。以下是在 MinIO 中配置防盗链的一般步骤&#xff1a; 编辑 config.json 文件&#xff1a; 找到 MinIO 服…
阅读更多...
【游戏专区】飞机大战

【游戏专区】飞机大战

打过飞机的人都知道&#xff0c;不是那么好打滴&#xff0c;求得麻袋&#xff0c;甩掉你那脑子里的黄色信息。活不多说&#xff0c;我们开始吧。 1、easyX的原理 基于Windows图形编程&#xff0c;将Windows下的复杂程序过程进行封装&#xff0c;仅给用户提供一个简单熟悉的接…
阅读更多...
第63天：服务攻防-框架安全CVE 复现DjangoFlaskNode.JSJQuery

第63天：服务攻防-框架安全CVE 复现DjangoFlaskNode.JSJQuery

目录 思维导图 案例一&#xff1a;JavaScript-开发框架安全-Jquery&Node node.js目录穿越 CVE-2021-21315命令执行 Jquery CVE-2018-9207 案例二&#xff1a;Python-开发框架安全-Django&Flask django cve_2019_14234 CVE-2021-35042 flask ssti 思维导图 案…
阅读更多...
最新文章

Copyright @ 2022~2023