算法 - 二分法 / 双指针 / 三指针 / 滑动窗口

文章目录

  • 🍺 二分法
    • 🍻 旋转数组
      • 🥂 33. 搜索旋转排序数组 [旋转数组] [目标值] (二分法)
    • 🍻 元素边界
      • 🥂 34. 在排序数组中查找元素的第一个和最后一个位置 [有序数组] > [元素边界] > (二分法)
      • 🥂 81. 搜索旋转排序数组Ⅱ [旋转数组] [有重] [目标值] (二分法)
      • 🥂 153. 寻找旋转排序数组中的最小值 [旋转数组] [最小值] (二分法)
  • 🍺 双指针
    • 🍻 元素合并
      • 🥂 21. 合并两个有序链表 [有序链表] [合并] (双指针) (归并)
    • 🍻 元素交换
      • 🥂 LCR 139. 训练计划 I [数组] [元素交换] (双指针)
    • 🍻 元素相交
      • 🥂 142. 环形链表II [链表] > [环] > (双指针)
      • 🥂 160. 相交链表 [链表] > [相交] > (双指针)
    • 🍻 面积
      • 🥂 11. 盛最多水的容器 [数组] [面积] (双指针)
      • 🥂 42. 接雨水 [数组] [面积] (双指针)
    • 🥂 其他
      • 🥂 31. 下一个排列 [数组] [排列] (双指针) (推导)
  • 🍺 三指针
    • 🍻 链表反转
      • 🥂 25. K 个一组翻转链表 [链表] [分组反转] (三指针)
      • 🥂 92. 反转链表II [链表] [反转] (三指针)
      • 🥂 206. 反转链表 [链表] [反转] (三指针)
    • 🍻 快速排序
      • 🥂 215. 数组中的第K个最大元素 [数组] [第K大元素] (三指针) (快速排序)
      • 🥂 912. 排序数组 [数组] [排序] (三指针) (快速排序)
  • 🍺 滑动窗口
    • 🍻 子串
      • 🥂 3. 无重复字符的最长子串 [字符串] [子串] (滑动窗口)
    • 🍻 区间和
      • 🥂 1423. 可获得的最大点数 [数组] > [区间外最大值] > [区间内最小值] > (定长滑动窗口)

🍺 二分法

🍻 旋转数组

🥂 33. 搜索旋转排序数组 [旋转数组] [目标值] (二分法)

class Solution {
public:int search(vector<int>& nums, int target) {int n = nums.size();int left = 0, right = n - 1;// 二分法while (left <= right) {int mid = left + (right - left) / 2;// 先判断找到目标了没if (nums[mid] == target) return mid;// 再继续左右两边找, nums[mid] < nums[0] 说明 mid 在右边if (nums[mid] <= nums[0]) {// 此时 target 处于右右边if (nums[mid] < target && target <= nums[n - 1]) {left = mid + 1;         // 右右} else {right = mid - 1;        // 右左}} else {if (nums[0] <= target && target < nums[mid]) {right = mid - 1;        // 左左} else {left = mid + 1;         // 左右}}}return -1;}
};

🍻 元素边界

🥂 34. 在排序数组中查找元素的第一个和最后一个位置 [有序数组] > [元素边界] > (二分法)

// [有序数组] > [查找元素边界] > (二分法)
class Solution {
public:vector<int> searchRange(vector<int>& nums, int target) {int left = find_l(nums, target);int right = find_r(nums,target);return {left, right};}// 二分法查找左边界 [left, right]int find_l(vector<int>& nums, int target) {int n = nums.size();int left = 0, right = n - 1;while (left <= right) {// [left, mid - 1] [mid] [mid + 1, right]int mid = left + (right - left) / 2;if (nums[mid] >= target) {right = mid - 1;} else {left = mid + 1;}}// left = 3, right = 3 - 1 = 2if (0 <= left && left < n && nums[left] == target) {return left;}return -1;}// 二分法查找右边界 [left, right]int find_r(vector<int>& nums, int target) {int n = nums.size();int left = 0, right = n - 1;while (left <= right) {// [left, mid - 1] [mid] [mid + 1, right]int mid = left + (right - left) / 2;if (nums[mid] > target) {right = mid - 1;} else {left = mid + 1;}}// right = 4, left = 4 + 1 = 5if (0 <= right && right < n && nums[right] == target) {return right;}return -1;}
};

🥂 81. 搜索旋转排序数组Ⅱ [旋转数组] [有重] [目标值] (二分法)

class Solution {
public:bool search(vector<int>& nums, int target) {int n = nums.size();int left = 0, right = n - 1;// 二分法while (left <= right) {// 判断是否存在int mid = left + (right - left) / 2;if (nums[mid] == target) return true;// 去除重复元素if (nums[mid] == nums[left]) {left++;continue;}if (nums[mid] == nums[right]) {right--;continue;}// 防止卡住, 区分不出左右if (nums[mid] < nums[0]) {  // 右// 再判断 target 在右边的左边还是右边 [left, mid-1][mid][mid+1, right]if (nums[mid] < target && target <= nums[n - 1]) {left = mid + 1;     // 右右} else {right = mid - 1;    // 右左}} else {                    // 左// 再判断 target 在左边的左边还是右边 [left, mid-1][mid][mid+1, right]if (nums[0] <= target && target < nums[mid]) {right = mid - 1;    // 左左} else {left = mid + 1;     // 左右}}}return false;}
};

🥂 153. 寻找旋转排序数组中的最小值 [旋转数组] [最小值] (二分法)

class Solution {
public:int findMin(vector<int>& nums) {int left = 0, right = nums.size() - 1;// 二分法 [0, n-1]while (left <= right) {int mid = left + (right - left) / 2;if (nums[mid] < nums[right]) {right = mid;} else if (nums[mid] > nums[right]) {left = mid + 1;} else {right--;}}return nums[left];}
};

🍺 双指针

🍻 元素合并

🥂 21. 合并两个有序链表 [有序链表] [合并] (双指针) (归并)

class Solution {
public:ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {// 虚拟头节点, 当前节点指向虚拟头节点ListNode* dummy = new ListNode(-1), * cur = dummy;// 双指针ListNode* p1 = list1, * p2 = list2;while (p1 != nullptr && p2 != nullptr) {if (p1->val < p2->val) {cur->next = p1;p1 = p1->next;} else {cur->next = p2;p2 = p2->next;}cur = cur->next;}// 剩下的直接拼上if (p1 != nullptr) cur->next = p1;if (p2 != nullptr) cur->next = p2;return dummy->next;}
};

🍻 元素交换

🥂 LCR 139. 训练计划 I [数组] [元素交换] (双指针)

class Solution {
public:vector<int> trainingPlan(vector<int>& actions) {int n = actions.size();if (n <= 1) return actions;// 定义双指针,一个指向头,一个指向尾int left = 0, right = n - 1;             while (left < right) {// 依次移动,找到数时暂停while (left < right && actions[left] % 2 == 1) {left++;}while (left < right && actions[right] % 2 == 0) {right--;}std::swap(actions[left], actions[right]);}return actions;}
};

🍻 元素相交

🥂 142. 环形链表II [链表] > [环] > (双指针)

// [链表] > [环] > (双指针)
class Solution {
public:ListNode *detectCycle(ListNode *head) {ListNode* dummy = new ListNode(-1);dummy->next = head;ListNode* fast = dummy, * slow = dummy;// 满指针走一步, 快指针走两步, 判断有无环while (fast->next && fast->next->next) {slow = slow->next;fast = fast->next->next;// 如果相遇, 则让满指针从头开始走, 两者同步移动if (fast == slow) {fast = dummy;while (fast != slow) {slow = slow->next;fast = fast->next;}return fast;}}return nullptr;   }
};

🥂 160. 相交链表 [链表] > [相交] > (双指针)

// [链表] > [相交] > (双指针)
class Solution {
public:ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {// 双指针ListNode *p1 = headA, *p2 = headB;// A 走到 nullptr 后接着走 B, B 走到 nullptr 后接着走 A// 当 p1 == p2 的地方就是相交的地方while (p1 != p2) {if (p1 == nullptr) p1 = headB;else p1 = p1->next;if (p2 == nullptr) p2 = headA;else p2 = p2->next;}return p1;}
};

🍻 面积

🥂 11. 盛最多水的容器 [数组] [面积] (双指针)

class Solution {
public:int maxArea(vector<int>& height) {// 双指针int left = 0, right = height.size() - 1;// 最大面积, 当前面积int res = 0, cur = 0;// 缩小区域while (left < right) {cur = min(height[left], height[right]) * (right - left);res = max(res, cur);// 哪一边比较短, 移动哪一边if (height[left] < height[right]) {left++;} else {right--;}}return res;}
};

🥂 42. 接雨水 [数组] [面积] (双指针)

class Solution {
public:int trap(vector<int>& height) {// 左边边界, 右边边界, 最边上存不了水int left = 0, right = height.size() - 1;// 左边最大值, 右边最大值int left_max = height[left], right_max = height[right];// 当前装水量, 总装水量int cur = 0, res = 0;while (left <= right) {left_max = max(left_max, height[left]);right_max = max(right_max, height[right]);if (left_max < right_max) {// 左指针的leftMax比右指针的rightMax矮// 说明:左指针的右边至少有一个板子 > 左指针左边所有板子// 那么可以计算左指针当前列的水量:左边最大高度-当前列高度res += left_max - height[left];left++;} else {res += right_max - height[right];right--;}}return res;}
};

🥂 其他

🥂 31. 下一个排列 [数组] [排列] (双指针) (推导)

class Solution {
private:int flag = 0;   // 设置一个标志位, 代表找到当前排列了
public:void nextPermutation(vector<int>& nums) {int n = nums.size();// 从后往前找, 找到第一个 nums[i] < nums[j] 的地方int i = n - 2, j = n - 1;while (i >= 0 && nums[i] >= nums[i + 1]) {i--;}// 此时不是最后一个排列if (i >= 0) {// 找到一个比 nums[i] 大的第一个元素while (j > i && nums[j] <= nums[i]) {j--;}// 交换两者swap(nums[i], nums[j]);// 再将剩余部分逆转, 把降序变为升序reverse(nums.begin() + i + 1, nums.end());} else {// 如果是最后一个排列reverse(nums.begin(), nums.end());}return;}
};

🍺 三指针

🍻 链表反转

🥂 25. K 个一组翻转链表 [链表] [分组反转] (三指针)

class Solution {
public:ListNode* reverseKGroup(ListNode* head, int k) {// 虚拟头节点ListNode* dummy = new ListNode(-1);     dummy->next = head;// 前置节点和后置节点ListNode* pre = dummy, * end = dummy;// 每次翻转 K 个节点while (end->next != nullptr) {for (int i = 0; i < k && end != nullptr; ++i) {end = end->next;}if (end == nullptr) break;// [pre] > [start] > [2] > [end] | [next] [5]ListNode* start = pre->next, * next = end->next;end->next = nullptr;// [pre] > [end] > [2] > [start] | [next] [5]pre->next = reverse(start);// [pre] > [end] > [2] > [start] > [next] [5]start->next = next;pre = start;end = start;}return dummy->next;}// 翻转链表ListNode* reverse(ListNode* head) {// [pre] | [cur] > [next]ListNode* pre = nullptr;ListNode* cur = head;while (cur != nullptr) {ListNode* next = cur->next;// [pre] < [cur] | [next]cur->next = pre;// [N] < [pre] | [cur]pre = cur;cur = next;}// 此时 cur 为空, pre 为最后一个非空节点return pre;} 
};

🥂 92. 反转链表II [链表] [反转] (三指针)

class Solution {
public:ListNode* reverseBetween(ListNode* head, int left, int right) {ListNode* dummy = new ListNode(-1);dummy->next = head;// 四个指针分别指向 pre start end next// [1] > [pre] > [start] > [4] > [5] > [end] > [next]ListNode* pre = dummy, * end = dummy;for (int i = 0; i < left - 1; ++i) pre = pre->next;cout << pre->val;for (int j = 0; j < right; ++j) end = end->next;ListNode* start = pre->next, * next = end->next;// [1] > [pre] > [start] > [4] > [5] > [end] | [next]end->next = nullptr;// [1] > [pre] > [end] > [5] > [4] > [start] | [next]pre->next = reverse(start);// [1] > [pre] > [end] > [5] > [4] > [start] > [next]start->next = next;return dummy->next;}// 翻转链表ListNode* reverse(ListNode* head) {// [pre] | [cur] > [next]ListNode* pre = nullptr;ListNode* cur = head;while (cur != nullptr) {ListNode* next = cur->next;// [pre] < [cur] | [next]cur->next = pre;// [N] < [pre] | [cur]pre = cur;cur = next;}// 此时 cur 为空, pre 为最后一个非空节点return pre;}
};

🥂 206. 反转链表 [链表] [反转] (三指针)

class Solution {
public:ListNode* reverseList(ListNode* head) {return reverse(head);}// 翻转链表ListNode* reverse(ListNode* head) {// [pre] | [cur] > [next]ListNode* pre = nullptr;ListNode* cur = head;while (cur != nullptr) {ListNode* next = cur->next;// [pre] < [cur] | [next]cur->next = pre;// [N] < [pre] | [cur]pre = cur;cur = next;}// 此时 cur 为空, pre 为最后一个非空节点return pre;}
};

🍻 快速排序

🥂 215. 数组中的第K个最大元素 [数组] [第K大元素] (三指针) (快速排序)

class Solution {
private:int target; // 目标索引, 第 n-k 小int res;    // 目标值
public:int findKthLargest(vector<int>& nums, int k) {// 快速排序, 每次可以确定好一个元素的位置, 当索引为 k 时, 代表找到int n = nums.size();// 第 k 大就是第 n - k 小target = n - k;// 开始快排quickSort(nums, 0, n - 1);return res;}// 快排 [left, right]void quickSort(vector<int>& nums, int left, int right) {if (left > right) return;// 只剩一个元素if (left == right && left == target) {res = nums[target];return;}// 先获取一个哨兵, 将数组分为小于它的部分和大于它的部分vector<int> edge = part(nums, left, right);// 如果 target 在左右边界之间, 则找到if (edge[0] <= target && target <= edge[1]) {res = nums[target];return;}// 继续递归quickSort(nums, left, edge[0] - 1);quickSort(nums, edge[1] + 1, right);}// 分隔, 三指针, 这里返回相同元素的左右边界是为了去重vector<int> part(vector<int>& nums, int left, int right) {int pivot_idx = rand() % (right - left + 1) + left;int pivot = nums[pivot_idx];// [pivot]  [1]  [2]  [3]  [4]//  L/LP    CP                  RP swap(nums[pivot_idx], nums[left]);// 设置三个指针, 分别指向小于 pivot 的元素, 当前元素, 大于 pivot 的元素int curp = left + 1, leftp = left, rightp = right + 1;// 还没走到尽头, rightp 始终是指向大于 pivot 元素的while (curp < rightp) {if (nums[curp] < pivot) {           // 小于哨兵leftp++;swap(nums[curp], nums[leftp]);curp++;} else if (nums[curp] > pivot) {    // 大于哨兵rightp--;swap(nums[curp], nums[rightp]);} else {                            // 相等, 什么也不做curp++;}}// 最后 leftp 指向的内容肯定是最后一个小于 pivot 的, 它与 pivot 交换swap(nums[left], nums[leftp]);// 返回等于 pivot 的左边界和右边界 [小于] [pivot] [大于]return {leftp, rightp - 1};}
};

🥂 912. 排序数组 [数组] [排序] (三指针) (快速排序)

class Solution {
public:vector<int> sortArray(vector<int>& nums) {int n = nums.size();quickSort(nums, 0, n - 1);return nums;}// 快排 [left, right]void quickSort(vector<int>& nums, int left, int right) {// 只剩一个元素, 就不用排了if (left > right) return;// 先获取一个哨兵, 将数组分为小于它的部分和大于它的部分vector<int> edge = part(nums, left, right);// 继续递归quickSort(nums, left, edge[0] - 1);quickSort(nums, edge[1] + 1, right);}// 分隔, 三指针, 这里返回相同元素的左右边界是为了去重vector<int> part(vector<int>& nums, int left, int right) {int pivot_idx = rand() % (right - left + 1) + left;int pivot = nums[pivot_idx];// [pivot]  [1]  [2]  [3]  [4]//  L/LP    CP                  RP swap(nums[pivot_idx], nums[left]);// 设置三个指针, 分别指向小于 pivot 的元素, 当前元素, 大于 pivot 的元素int curp = left + 1, leftp = left, rightp = right + 1;// 还没走到尽头, rightp 始终是指向大于 pivot 元素的while (curp < rightp) {if (nums[curp] < pivot) {           // 小于哨兵leftp++;swap(nums[curp], nums[leftp]);curp++;} else if (nums[curp] > pivot) {    // 大于哨兵rightp--;swap(nums[curp], nums[rightp]);} else {                            // 相等, 什么也不做curp++;}}// 最后 leftp 指向的内容肯定是最后一个小于 pivot 的, 它与 pivot 交换swap(nums[left], nums[leftp]);// 返回等于 pivot 的左边界和右边界 [小于] [pivot] [大于]return {leftp, rightp - 1};}
};

🍺 滑动窗口

🍻 子串

🥂 3. 无重复字符的最长子串 [字符串] [子串] (滑动窗口)

class Solution {
private:unordered_map<char, int> umap;      // 滑动窗口int res = 0;                        // 存放结果
public:int lengthOfLongestSubstring(string s) {int n = s.size();int left = 0, right = 0;        // 窗口边界while (right < n) {char cur_r = s[right++];    // 取当前字符串umap[cur_r]++;              // 更新窗口内容// 判断是否该缩小窗口while (umap[cur_r] > 1) {char cur_l = s[left++];umap[cur_l]--;}// 此时已经没有重复元素出现 [left, right)res = max(res, right - left);}return res;}
};

🍻 区间和

🥂 1423. 可获得的最大点数 [数组] > [区间外最大值] > [区间内最小值] > (定长滑动窗口)

// [数组] > [区间外最大值] > [区间内最小值] > (定长滑动窗口)
class Solution {
public:int maxScore(vector<int>& cardPoints, int k) {int n = cardPoints.size();int windowSize = n - k;// [0, n-k] 的区间和int sum = accumulate(cardPoints.begin(), cardPoints.begin() + windowSize, 0);int min_val = sum;          // 窗口的最小值// 移动for (int i = 0; i < n - windowSize; ++i) {int left = i, right = i + windowSize;sum += cardPoints[right] - cardPoints[left];min_val = min(min_val, sum);}return accumulate(cardPoints.begin(), cardPoints.end(), 0) - min_val;}
};

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

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

相关文章

IOS元素定位对应关系

resource-id也称为id&#xff0c;resource-id是唯一的 # 元素定位 agree_continue_id "com.baidu.searchbox:id/positive_button" WebDriverWait(driver, 10, 1).until(EC.visibility_of_element_located((MobileBy.ID, agree_continue_id))) driver.find_element…

Databend 开源周报第 128 期

Databend 是一款现代云数仓。专为弹性和高效设计&#xff0c;为您的大规模分析需求保驾护航。自由且开源。即刻体验云服务&#xff1a;https://app.databend.cn 。 Whats On In Databend 探索 Databend 本周新进展&#xff0c;遇到更贴近你心意的 Databend 。 使用 Databend …

[Linux 进程(四)] 再谈环境变量,程序地址空间初识

文章目录 1、前言2、环境变量2.1 main函数第三个参数 -- 环境参数表2.2 本地环境变量和env中的环境变量2.3 配置文件与环境变量的全局性2.4 内建命令与常规命令2.5 环境变量相关的命令 3、程序地址空间 1、前言 上一篇我们讲了环境变量&#xff0c;如果有不明白的先读一下上一…

C++ 编程需要什么样的开发环境?

C 编程需要什么样的开发环境&#xff1f; 在开始前我有一些资料&#xff0c;是我根据网友给的问题精心整理了一份「C的资料从专业入门到高级教程」&#xff0c; 点个关注在评论区回复“888”之后私信回复“888”&#xff0c;全部无偿共享给大家&#xff01;&#xff01;&#…

C++ 拾遗 2

1.变量的作用域 1&#xff09;全局变量 在整个程序生命周期内都是有效的&#xff0c;在定义位置之后的任意函数中都能访问。 全局变量在主程序退出时由系统收回内存空间。 2&#xff09;局部变量 在函数或语句块内部的语句使用&#xff0c;在函数或语句块外部是不可用的。 …

网页设计-用户体验

Use Cases (用例) 用例是用户如何在网站上执行任务的书面描述&#xff0c;从用户的角度描述了系统响应请求时的行为。每个用例都是用户实现目标的一系列简单的步骤。简言之&#xff0c;用例是一种用于描述系统如何满足用户需求的方法。 用例的好处 1. 明确需求&#xff1a; Use…

Python办公自动化 – 可以解析的文件格式和可以调用的API实现办公自动化

Python办公自动化 – 可以解析的文件格式和可以调用的API实现办公自动化 以下是往期的文章目录&#xff0c;需要可以查看哦。 Python办公自动化 – Excel和Word的操作运用 Python办公自动化 – Python发送电子邮件和Outlook的集成 Python办公自动化 – 对PDF文档和PPT文档的处…

Unity与Android交互通信系列(4)

上篇文章我们实现了模块化调用&#xff0c;运用了模块化设计思想和简化了调用流程&#xff0c;本篇文章讲述UnityPlayerActivity类的继承和使用。 在一些深度交互场合&#xff0c;比如Activity切换、程序启动预处理等&#xff0c;这时可能会需要继承Application和UnityPlayerAc…

Windows系统字体尺寸学习

调用GetTextMetrics来获得字体尺寸信息, 函数返回设备描述表中当前选定的字体信息&#xff1b; 返回值到TEXTMETRIC类型的结构中&#xff1b; 返回字段值的单位取决于当前设备描述表映射方式&#xff1b;默认映射方式是MM_TEXT&#xff0c;值的单位是像素&#xff1b; 前7个字…

多模型图像特征可视化

特征图可视化是指将网络中某一层的特征图可视化出来&#xff0c;以便观察网络在不同层次上学到的特征。卷积可视化可以帮助深度学习研究者更好地理解卷积的概念和原理&#xff0c;从而更好地设计和优化卷积神经网络。通过可视化&#xff0c;研究者可以更清晰地看到卷积运算中的…

【程序员的自我修养—系统调用与API】

系统调用 背景&#xff1a; 为了避免有限的系统资源被多个不同的应用程序同时访问&#xff0c;需要加以保护&#xff0c;避免冲突&#xff1b;提供一套统一的接口&#xff0c;是应用程序能做一些由操作系统支持的行为&#xff1b;接口通过中断的方式实现&#xff0c;Linux使用…

openssl3.2 - 官方demo学习 - pkey - EVP_PKEY_DSA_keygen.c

文章目录 openssl3.2 - 官方demo学习 - pkey - EVP_PKEY_DSA_keygen.c概述笔记END openssl3.2 - 官方demo学习 - pkey - EVP_PKEY_DSA_keygen.c 概述 das.h 中有2个公共函数(给pkey目录的所有工程公用): print_bn() 打印大数值 dsa_print_key() 打印key值 打印_evp_pkey_dsa…

[SS]语义分割——基础知识

语义分割前言 一、定义 1、概念 语义分割&#xff08;Semantic Segmentation&#xff09;是计算机视觉中的一项任务&#xff0c;目标是将图像中的每个像素按其语义类别进行分类。与传统的目标检测不同&#xff0c;语义分割对图像中的每个像素都进行分类&#xff0c;而不是只…

Vue 如何把computed里的逻辑提取出来

借用一下百度的ai 项目使用&#xff1a; vue 文件引入 <sidebar-itemv-for"route in routes":key"route.menuCode":item"route":base-path"route.path"click"onColor"/>import { handleroutes } from "./handle…

牛客-寻找第K大、LeetCode215. 数组中的第K个最大元素【中等】

文章目录 前言牛客-寻找第K大、LeetCode215. 数组中的第K个最大元素【中等】题目及类型思路思路1&#xff1a;大顶堆思路2&#xff1a;快排二分随机基准点 前言 博主所有博客文件目录索引&#xff1a;博客目录索引(持续更新) 牛客-寻找第K大、LeetCode215. 数组中的第K个最大元…

vue 开发规范

命名规范 不使用保留字 变量 小驼峰能描述变量内容复数加s // 我的app名称为朝阳的百宝箱 let myAppName 朝阳的百宝箱// 我的书籍有《卓有成效的管理者》、《牧羊少年奇幻之旅》 let myBooks [‘《卓有成效的管理者》’,‘《牧羊少年奇幻之旅》’]常量 全大写用_分隔单词…

ARCGIS PRO SDK Annotation 概念及操作

使用Annotation的API功能。Annotation 的API功能位于ArcGIS.Core.dll中。Annotation API通常与地理数据库、地图创作和编辑结合使用。ArcGIS.Core.dll ArcGIS.Core.Data.map API中的几乎所有方法都应该在MCT上调用。 一、Annotation featureclass 1、从GeodatabaseGeodatabase数…

MyBatis-Plus之内置接口Service接口Mapper接口

目录 1.Service接口 1.1.Save 1.2.SaveOrUpdate 1.3.Remove 1.4.Update 1.5.Get 1.6.List 2.Mapper接口 2.1.Insert 2.2.Delete 2.3.Update 2.4.Select 1.Service接口 Service CRUD 接口说明&#xff1a; 通用 Service CRUD 封装IService接口&#xff0c;进一步封…

C#: CRC8,CRC16,CRC32 校验代码

说明&#xff1a;CRC即循环冗余校验码&#xff08;Cyclic Redundancy Check&#xff09;&#xff1a;是数据通信领域中最常用的一种查错校验码&#xff0c;其特征是信息字段和校验字段的长度可以任意选定。循环冗余检查&#xff08;CRC&#xff09;是一种数据传输检错功能&…

统计学-R语言-5.1

文章目录 前言随机性和规律性概率变量的分布离散型--二项、泊松、几何二项分布几何分布泊松分布 连续型--均匀、正态均匀分布正态分布 其它统计分布--χ2分布、t分布、F分布χ2分布t分布F分布 练习 前言 从本篇文章开始介绍有关概率与分布的介绍。 随机性和规律性 当不能预测…