算法沉淀——分治算法（leetcode真题剖析）

在这里插入图片描述

算法沉淀——分治算法

  • 快排思想
    • 01.颜色分类
    • 02.排序数组
    • 03.数组中的第K个最大元素
    • 04.库存管理 III
  • 归并思想
    • 01.排序数组
    • 02.交易逆序对的总数
    • 03.计算右侧小于当前元素的个数
    • 04.翻转对

分治算法是一种解决问题的算法范式，其核心思想是将一个大问题分解成若干个小问题，递归地解决这些小问题，最后将它们的解合并起来得到原问题的解。分治算法的一般步骤包括分解（Divide）、解决（Conquer）、合并（Combine）。

具体来说，分治算法包含以下几个步骤：

  1. 分解（Divide）： 将原问题分解成若干个规模较小、相互独立的子问题。这一步通常是问题规模的减小或者数据规模的缩小。
  2. 解决（Conquer）： 递归地解决这些子问题。对于规模较小的子问题，可以直接求解。
  3. 合并（Combine）： 将子问题的解合并起来，得到原问题的解。

分治算法通常适用于能够被划分成相互独立子问题的问题，并且这些子问题的结构和原问题一样。经典的分治算法有许多，如归并排序、快速排序、二分搜索等。

经典例子：归并排序

  1. 分解（Divide）： 将待排序的数组分成两半。
  2. 解决（Conquer）： 对每个子数组进行归并排序，递归地进行排序。
  3. 合并（Combine）： 合并已排序的子数组，得到最终的排序结果。

分治算法的优点包括：

  • 模块化设计： 将问题分解成小问题，使得算法结构清晰，易于理解和实现。
  • 可并行性： 分治算法通常适用于并行计算，因为子问题可以独立地求解。
  • 适用范围广： 适用于一类问题，如排序、查找等。

快排思想

01.颜色分类

题目链接：https://leetcode.cn/problems/sort-colors/

给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

必须在不使用库内置的 sort 函数的情况下解决这个问题。

示例 1：

输入：nums = [2,0,2,1,1,0]
输出：[0,0,1,1,2,2]

示例 2：

输入：nums = [2,0,1]
输出：[0,1,2]

提示：

  • n == nums.length
  • 1 <= n <= 300
  • nums[i] 为 0、1 或 2

思路

具体的思路可以分为以下三个部分：

  1. 红色部分（0）： 通过交换，保证红色元素的右边界 left 的左侧都是红色元素。初始时，left 设置为-1。
  2. 白色部分（1）： 遍历过程中，遇到白色元素（1）时，直接将指针 i 向右移动，不进行交换。白色元素已经排列在红色元素的右侧，所以不需要额外操作。
  3. 蓝色部分（2）： 通过交换，保证蓝色元素的左边界 right 的右侧都是蓝色元素。初始时，right 设置为数组的长度。

整个过程在遍历指针 i 小于右边界 right 的情况下进行。当 i 与 right 相遇时，排序完成。

代码

class Solution {
public:void sortColors(vector<int>& nums) {for(int i=0,left=-1,right=nums.size();i<right;){if(nums[i]==0) swap(nums[++left],nums[i++]);else if(nums[i]==1) i++;else swap(nums[i],nums[--right]);}}
};

02.排序数组

题目链接：https://leetcode.cn/problems/sort-an-array/

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：

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

示例 2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

提示：

  • 1 <= nums.length <= 5 * 104
  • -5 * 104 <= nums[i] <= 5 * 104

思路

普通快排在这里是通过不了的，所以我们可以使用上面颜色分类的思想进行三路划分的优化

三路划分是对传统快速排序算法的一种改进，通过将数组划分为三个部分：小于、等于、大于基准值，从而在存在大量相同元素的情况下，提高了性能。

传统快速排序在处理有大量相同元素的数组时可能会导致不均匀的划分，使得递归树不平衡，进而影响性能。三路划分通过在划分过程中将数组分为小于、等于、大于基准值的三个部分，有效地解决了这一问题，具有以下优势：

  1. 减少重复元素的递归处理： 在存在大量相同元素的情况下，传统快速排序可能导致递归深度较大，而三路划分能够将相同元素聚集在一起，从而减少递归深度。
  2. 避免不必要的交换： 在传统快速排序中，可能会进行多次相同元素的交换，而三路划分通过将相同元素聚集在一起，避免了不必要的交换操作，提高了性能。
  3. 适用于含有大量重复元素的场景： 当数组中存在大量相同元素时，三路划分能够更好地利用重复元素的信息，提高排序效率。

三路划分的核心思想是通过一个循环，将数组划分为小于、等于、大于基准值的三个部分。这样，相同元素被聚集在等于基准值的部分，从而在递归过程中能够更高效地处理重复元素。这一优化使得算法在处理包含大量相同元素的数组时，性能更为稳定。

代码

class Solution {
public:int getRandom(vector<int>& nums,int left, int right){return nums[rand()%(right-left+1)+left];}void qsort(vector<int>& nums,int l, int r){if(l>=r) return;int key=getRandom(nums,l,r);int i=l,left=l-1,right=r+1;while(i<right){if(nums[i]<key) swap(nums[++left],nums[i++]);else if(nums[i]==key) i++;else swap(nums[--right],nums[i]);}qsort(nums,l,left);qsort(nums,right,r);}vector<int> sortArray(vector<int>& nums) {srand(time(NULL));qsort(nums,0,nums.size()-1);return nums;}
};

03.数组中的第K个最大元素

题目链接：https://leetcode.cn/problems/kth-largest-element-in-an-array/

给定整数数组 nums 和整数 k，请返回数组中第 **k** 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

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

示例 1:

输入: [3,2,1,5,6,4], k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4

提示：

  • 1 <= k <= nums.length <= 105
  • -104 <= nums[i] <= 104

思路

这里最常规的写法应该是使用堆排，但是这样达不到O(n)的时间复杂度，所以这里我们结合快排中的三路划分思想

代码

class Solution {
public:int findKthLargest(vector<int>& nums, int k) {srand(time(NULL));  // 设置随机数种子return qsort(nums, 0, nums.size() - 1, k);}int qsort(vector<int>& nums, int l, int r, int k) {if (l == r) return nums[l];// 1. 随机选择基准元素int key = getRandom(nums, l, r);// 2. 根据基准元素将数组分为三块int left = l - 1, right = r + 1, i = l;while (i < right) {if (nums[i] < key) {swap(nums[++left], nums[i++]);} else if (nums[i] == key) {i++;} else {swap(nums[--right], nums[i]);}}// 3. 分情况讨论int c = r - right + 1, b = right - left - 1;if (c >= k) {// 第 k 大元素在右侧部分return qsort(nums, right, r, k);} else if (b + c >= k) {// 第 k 大元素等于基准元素return key;} else {// 第 k 大元素在左侧部分return qsort(nums, l, left, k - b - c);}}int getRandom(vector<int>& nums, int left, int right) {return nums[rand() % (right - left + 1) + left];}
};
  1. 计算左、右和基准三个部分的元素个数：
    • c 表示右侧部分元素的个数，即大于基准元素的个数。
    • b 表示基准元素左侧部分元素的个数，即等于基准元素的个数。
  2. 判断第 k 大元素的位置：
    • 如果右侧部分元素个数 c 大于等于 k，说明第 k 大元素在右侧部分。因此，递归地在右侧部分中继续寻找第 k 大元素。
    • 如果 b + c 大于等于 k，说明第 k 大元素等于基准元素。此时，基准元素即为所求的第 k 大元素，直接返回基准元素的值。
    • 如果以上两个条件都不满足，说明第 k 大元素在左侧部分。因此，递归地在左侧部分中继续寻找第 k 大元素，同时将 k 减去右侧和基准元素的个数。

这样的划分和递归过程保证了在不同情况下都能正确地找到第 k 大元素，从而完成整个算法。这是随机化快速排序在选择第 k 大元素时的一种处理策略，通过考虑基准元素左右两侧的元素个数，提高了算法在寻找第 k 大元素时的效率。

04.库存管理 III

题目链接：https://leetcode.cn/problems/zui-xiao-de-kge-shu-lcof/

仓库管理员以数组 stock 形式记录商品库存表，其中 stock[i] 表示对应商品库存余量。请返回库存余量最少的 cnt 个商品余量，返回 顺序不限。

示例 1：

输入：stock = [2,5,7,4], cnt = 1
输出：[2]

示例 2：

输入：stock = [0,2,3,6], cnt = 2
输出：[0,2] 或 [2,0]

提示：

  • 0 <= cnt <= stock.length <= 10000 0 <= stock[i] <= 10000

思路

这一题和上一题的思路基本一致，同样我们使用快速选择的算法，可以使时间复杂度达到O(n)，只不过需要简单做一些调整

代码

class Solution {
public:void qsort(vector<int>& nums, int l, int r, int k) {if (l >= r) return;// 随机选择基准元素int key = nums[rand() % (r - l + 1) + l];int left = l - 1, right = r + 1, i = l;// 划分过程while (i < right) {if (nums[i] < key) {swap(nums[++left], nums[i++]);} else if (nums[i] == key) {i++;} else {swap(nums[--right], nums[i]);}}int a = left - l + 1, b = right - left - 1;// 根据划分情况递归处理if (a > k) {// 第 k 小元素在左侧部分qsort(nums, l, left, k);} else if (a + b >= k) {// 第 k 小元素在基准元素右侧，且可能包含部分基准元素return;} else {// 第 k 小元素在右侧部分qsort(nums, right, r, k - a - b);}}vector<int> inventoryManagement(vector<int>& stock, int cnt) {srand(time(NULL));// 调用随机化快速排序qsort(stock, 0, stock.size() - 1, cnt);// 返回前 cnt 小的商品return {stock.begin(), stock.begin() + cnt};}
};

归并思想

01.排序数组

题目链接：https://leetcode.cn/problems/sort-an-array/

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：

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

示例 2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

提示：

  • 1 <= nums.length <= 5 * 104
  • -5 * 104 <= nums[i] <= 5 * 104

思路

要理解分治中的归并思想，首先我们从归并排序入手，这里我直接编写代码，想看更清晰的排序剖析，可以翻看博主之前关于八大排序的博客

代码

class Solution {vector<int> tmp;
public:vector<int> sortArray(vector<int>& nums) {tmp.resize(nums.size());mergeSort(nums, 0, nums.size() - 1);return nums;}void mergeSort(vector<int>& nums, int left, int right) {if (left >= right) return;// 计算中间位置int mid = (right + left) >> 1;// 递归对左右两部分进行归并排序mergeSort(nums, left, mid);mergeSort(nums, mid + 1, right);// 归并合并两个有序部分int cur1 = left, cur2 = mid + 1, i = 0;while (cur1 <= mid && cur2 <= right)tmp[i++] = (nums[cur1] <= nums[cur2]) ? nums[cur1++] : nums[cur2++];while (cur1 <= mid) tmp[i++] = nums[cur1++];while (cur2 <= right) tmp[i++] = nums[cur2++];// 将归并后的结果拷贝回原数组for (int i = left; i <= right; ++i)nums[i] = tmp[i - left];}
};

02.交易逆序对的总数

题目链接：https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof/

在股票交易中，如果前一天的股价高于后一天的股价，则可以认为存在一个「交易逆序对」。请设计一个程序，输入一段时间内的股票交易记录 record，返回其中存在的「交易逆序对」总数。

示例 1:

输入：record = [9, 7, 5, 4, 6]
输出：8
解释：交易中的逆序对为 (9, 7), (9, 5), (9, 4), (9, 6), (7, 5), (7, 4), (7, 6), (5, 4)。

限制：

0 <= record.length <= 50000

思路

这里我们使用归并的思想可以对数组边排序边进行逆序对的计算，我们在进行归并排序划分时，左边和右边都是相对有序的，我们在归并时，找到了左边相对右边大的那个数，就可以进行一次逆序对的组合，即此时左边被遍历的数及其之后的数都能和此时右边的数进行逆序匹配，此时我们累加逆序对的值，直到我们把整个数组归并完毕，逆序对的总数也就计算完毕了

代码

class Solution {int tmp[50000];
public:int reversePairs(vector<int>& record) {return mergeSort(record, 0, record.size() - 1);}int mergeSort(vector<int>& nums, int left, int right) {if (left >= right) return 0;int ret = 0;int mid = (left + right) >> 1;// 递归对左右两部分进行归并排序ret += mergeSort(nums, left, mid);ret += mergeSort(nums, mid + 1, right);// 归并合并两个有序部分，并统计逆序对个数int cur1 = left, cur2 = mid + 1, i = 0;while (cur1 <= mid && cur2 <= right) {if (nums[cur1] <= nums[cur2]) {tmp[i++] = nums[cur1++];} else {ret += mid - cur1 + 1;  // 统计逆序对个数tmp[i++] = nums[cur2++];}}while (cur1 <= mid) tmp[i++] = nums[cur1++];while (cur2 <= right) tmp[i++] = nums[cur2++];// 将归并后的结果拷贝回原数组for (int i = left; i <= right; ++i)nums[i] = tmp[i - left];return ret;}
};

03.计算右侧小于当前元素的个数

题目链接：https://leetcode.cn/problems/count-of-smaller-numbers-after-self/

给你一个整数数组 nums ，按要求返回一个新数组 counts 。数组 counts 有该性质： counts[i] 的值是 nums[i] 右侧小于 nums[i] 的元素的数量。

示例 1：

输入：nums = [5,2,6,1]
输出：[2,1,1,0] 
解释：
5 的右侧有 2 个更小的元素 (2 和 1)
2 的右侧仅有 1 个更小的元素 (1)
6 的右侧有 1 个更小的元素 (1)
1 的右侧有 0 个更小的元素

示例 2：

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

示例 3：

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

提示：

  • 1 <= nums.length <= 105
  • -104 <= nums[i] <= 104

思路

我们可以继续利用上面的逆序对思想，只不过我们需要使用额外的数组来记录相对下标。

代码

class Solution {vector<int> ret;vector<int> index;int tmp[500000];int tindex[500000];
public:vector<int> countSmaller(vector<int>& nums) {int n=nums.size();ret.resize(n);index.resize(n);for(int i=0;i<n;i++)  index[i]=i;mergeSort(nums,0,n-1);return ret;}void mergeSort(vector<int>& nums,int left,int right){if(left>=right) return;int mid=(left+right)>>1;mergeSort(nums,left,mid);mergeSort(nums,mid+1,right);int cur1=left,cur2=mid+1,i=0;while(cur1<=mid&&cur2<=right){if(nums[cur1]<=nums[cur2]){tmp[i]=nums[cur2];tindex[i++]=index[cur2++];}else{ret[index[cur1]]+=right-cur2+1;tmp[i]=nums[cur1];tindex[i++]=index[cur1++];}}while(cur1<=mid){tmp[i]=nums[cur1];tindex[i++]=index[cur1++];}while(cur2<=right){tmp[i]=nums[cur2];tindex[i++]=index[cur2++];}for(int j=left;j<=right;j++){nums[j]=tmp[j-left];index[j]=tindex[j-left];}}
};

04.翻转对

题目链接：https://leetcode.cn/problems/reverse-pairs/

给定一个数组 nums ，如果 i < j 且 nums[i] > 2*nums[j] 我们就将 (i, j) 称作一个*重要翻转对*。

你需要返回给定数组中的重要翻转对的数量。

示例 1:

输入: [1,3,2,3,1]
输出: 2

示例 2:

输入: [2,4,3,5,1]
输出: 3

注意:

  1. 给定数组的长度不会超过50000。
  2. 输入数组中的所有数字都在32位整数的表示范围内。

思路

总体思路依旧是使用归并，我们在每次排序前，找到当前的左边某个数大于右边的两倍，即可一次性计算该数后面的翻转对个数，数组排序完成，即可计算全部的翻转对

代码

class Solution {int tmp[50000];
public:int reversePairs(vector<int>& nums) {return mergeSort(nums,0,nums.size()-1);}int mergeSort(vector<int>& nums,int left,int right){if(left>=right) return 0;int ret=0;int mid=(left+right)>>1;ret+=mergeSort(nums,left,mid);ret+=mergeSort(nums,mid+1,right);int cur1=left,cur2=mid+1,i=left;while(cur1<=mid){while(cur2<=right&&nums[cur2]>=nums[cur1]/2.0) cur2++;if(cur2>right) break;ret+=right-cur2+1;cur1++;}cur1=left,cur2=mid+1;while(cur1<=mid&&cur2<=right) tmp[i++]=nums[cur1]<=nums[cur2]?nums[cur2++]:nums[cur1++];while(cur1<=mid) tmp[i++]=nums[cur1++];while(cur2<=right) tmp[i++]=nums[cur2++];for(int j=left;j<=right;j++)nums[j]=tmp[j];return ret;}
};

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

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

相关文章

Unity笔记：相机移动

Unity笔记：相机移动

基础知识 鼠标输入 在Unity中&#xff0c;开发者在“Edit” > “Project Settings” > “Input Manager”中设置输入&#xff0c;如下图所示&#xff1a; 在设置了Mouse X后&#xff0c;Input.GetAxis("Mouse X")返回的是鼠标在X轴上的增量值。这意味着它会…
阅读更多...
Solidworks：从2D走向3D

Solidworks：从2D走向3D

Sokidworks 的强大之处在于三维实体建模&#xff0c;这个形状看似复杂&#xff0c;实际上只需要拉伸一次&#xff0c;再做一次减法拉伸就行了。第一次做三维模型&#xff0c;费了不少时间才搞明白。 接下来做一个稍微复杂一点的模型&#xff0c;和上面这个操作差不多&#xff0…
阅读更多...
LeetCode.144. 二叉树的前序遍历

LeetCode.144. 二叉树的前序遍历

题目 144. 二叉树的前序遍历 分析 这道题目是比较基础的题目&#xff0c;我们首先要知道二叉树的前序遍历是什么&#xff1f; 就是【根 左 右】 的顺序&#xff0c;然后利用递归的思想&#xff0c;就可以得到这道题的答案&#xff0c;任何的递归都可以采用 栈 的结构来实现…
阅读更多...
利用Windows10漏洞破解密码(保姆级教学)

利用Windows10漏洞破解密码(保姆级教学)

前言: 本篇博客只是技术分享并非非法传播知识,实验内容均是在虚拟机中进行,并非真实环境 正文: 一.windows10电脑密码破解 1)开启windows10虚拟机,停留在这个页面 2&#xff09;按5次Shift键,出现这个粘滞键,如果没有出现的,则说明漏洞已经修复 3)重新启动,在这个页面的时候…
阅读更多...
Qt网络编程-TCP与UDP

Qt网络编程-TCP与UDP

网络基础 TCP与UDP基础 关于TCP与UDP的基础这里就不过多介绍了&#xff0c;具体可以查看对应百度百科介绍&#xff1a; TCP&#xff08;传输控制协议&#xff09;_百度百科 (baidu.com) UDP_百度百科 (baidu.com) 需要知道这两者的区别&#xff1a; 可靠性&#xff1a; TC…
阅读更多...
【C语言】实现单链表

【C语言】实现单链表

目录 &#xff08;一&#xff09;头文件 &#xff08;二&#xff09;功能实现 &#xff08;1&#xff09;打印单链表 &#xff08;2&#xff09;头插与头删 &#xff08;3&#xff09;尾插与尾删 &#xff08;4&#xff09; 删除指定位置节点 和 删除指定位置之后的节点 …
阅读更多...
【工作学习 day04】 9. uniapp 页面和组件的生命周期

【工作学习 day04】 9. uniapp 页面和组件的生命周期

问题描述 uniapp常用的有&#xff1a;页面和组件&#xff0c;并且页面和组件各自有各自的生命周期函数&#xff0c;那么在页面/组件请求数据时&#xff0c;是用created呢&#xff0c;还是用onLoad呢&#xff1f; 先说结论: 组件使用组件的生命周期&#xff0c;页面使用页面的…
阅读更多...
第62讲商品搜索动态实现以及性能优化

第62讲商品搜索动态实现以及性能优化

商品搜索后端动态获取数据 后端动态获取数据&#xff1a; /*** 商品搜索* param q* return*/GetMapping("/search")public R search(String q){List<Product> productList productService.list(new QueryWrapper<Product>().like("name", q)…
阅读更多...
【Java程序设计】【C00260】基于Springboot的企业客户信息反馈平台（有论文）

【Java程序设计】【C00260】基于Springboot的企业客户信息反馈平台（有论文）

基于Springboot的企业客户信息反馈平台&#xff08;有论文&#xff09; 项目简介项目获取开发环境项目技术运行截图 项目简介 这是一个基于Springboot的企业客户信息反馈平台 本系统分为平台功能模块、管理员功能模块以及客户功能模块。 平台功能模块&#xff1a;在平台首页可…
阅读更多...
python从入门到精通（十六）：python爬虫的BeautifulSoup4

python从入门到精通（十六）：python爬虫的BeautifulSoup4

python爬虫的BeautifulSoup4 BeautifulSoup4导入模块解析文件创建对象python解析器beautifulsoup对象的种类Tag获取整个标签获取标签里的属性和属性值Navigablestring 获取标签里的内容BeautifulSoup获取整个文档Comment输出的内容不包含注释符号BeautifulSoup文档遍历Beautifu…
阅读更多...
OpenCV-36 多边形逼近与凸包

OpenCV-36 多边形逼近与凸包

目录 一、多边形的逼近 二、凸包 一、多边形的逼近 findContours后的轮廓信息countours可能过于复杂不平滑&#xff0c;可以用approxPolyDP函数对该多边形曲线做适当近似&#xff0c;这就是轮廓的多边形逼近。 apporxPolyDP就是以多边形去逼近轮廓&#xff0c;采用的是Doug…
阅读更多...
Android9~Android13 某些容量SD卡被格式化为内部存储时容量显示错误问题的研究与解决方案

Android9~Android13 某些容量SD卡被格式化为内部存储时容量显示错误问题的研究与解决方案

声明：原创文章，禁止转载！ Android9~Android13 某些容量SD卡被格式化为内部存储时容量显示错误问题的研究与解决方案 分析Android11 系统对于EMMC/UFS作为内部存储、SD卡被格式化为内部存储、SD卡/U盘被格式化为便携式存储的不同处理 一.现象描述 实测Android9 Android10 A…
阅读更多...
牛客错题整理——C语言（实时更新）

牛客错题整理——C语言（实时更新）

1.以下程序的运行结果是&#xff08;&#xff09; #include <stdio.h> int main() { int sum, pad,pAd; sum pad 5; pAd sum, pAd, pad; printf("%d\n",pAd); }答案为7 由于赋值运算符的优先级高于逗号表达式&#xff0c;因此pAd sum, pAd, pad;等价于(…
阅读更多...
速度规划：s形曲线应用（变速 停车）opencv c++显示（3）

速度规划：s形曲线应用（变速 停车）opencv c++显示（3）

理论篇 先看该篇&#xff0c;这里沿用了里面的变量。 应用推导篇 分为变速和停车两部分&#xff08;字迹潦草&#xff0c;可结合代码看&#xff09; 代码篇 变速函数入口&#xff1a; velocityPlanner vp; vp.SetParameters(0, 1);停车函数入口&#xff1a; ParkingVelo…
阅读更多...
6 scala-面向对象编程基础

6 scala-面向对象编程基础

Scala 跟 Java 一样&#xff0c;是一门面向对象编程的语言&#xff0c;有类和对象的概念。 1 类与对象 与 Java 一样&#xff0c;Scala 也是通过关键字 class 来定义类&#xff0c;使用关键字 new 创建对象。 要运行我们编写的代码&#xff0c;同样像 Java 一样&#xff0c;…
阅读更多...
uniapp小程序端使用计算属性动态绑定style样式踩坑

uniapp小程序端使用计算属性动态绑定style样式踩坑

踩坑点: 使用uniapp编译小程序端动态绑定复杂style使用计算属性方式&#xff0c;return必须返回json字符串格式&#xff0c;不能返回object&#xff0c;否则会不起作用。 代码总览 视图层 逻辑层&#xff08;注意这里是使用的计算属性哈&#xff09; 这里我封装成了一个个性化…
阅读更多...
蓝桥杯嵌入式第9届真题(完成) STM32G431

蓝桥杯嵌入式第9届真题(完成) STM32G431

蓝桥杯嵌入式第9届真题(完成) STM32G431 题目 分析和代码 main.h /* USER CODE BEGIN Header */ /********************************************************************************* file : main.h* brief : Header for main.c file.* …
阅读更多...
Ubuntu Desktop - Terminal 输出全部选中 + 复制

Ubuntu Desktop - Terminal 输出全部选中 + 复制

Ubuntu Desktop - Terminal 输出全部选中 复制 1. Terminal2. Terminal 最大化3. Edit -> Select All4. Copy & PasteReferences 1. Terminal 2. Terminal 最大化 3. Edit -> Select All 4. Copy & Paste Edit -> Copy or Shift Ctrl C Edit -> Paste…
阅读更多...
PV、UV、IP

PV、UV、IP

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言1. PV1.1 PV 计算1.2 PV 的影响因素 2. UV2.1 UV 计算2.2UV 的影响因素 3. IP3.1 IP和UV①UV大于IP②UV小于IP 三者的关系PV 和 UV 前言 PV、UV、IP是我们在运…
阅读更多...
印度5G不是比中国先进，而是印度用户敢用，中国用户不敢用！

印度5G不是比中国先进，而是印度用户敢用，中国用户不敢用！

分析机构OpenSignal给出的数据指出中国手机用户的平均速率比印度用户还要低&#xff0c;这说明中国5G落后于印度&#xff0c;其实这是片面的说法&#xff0c;中国运营商的5G网络能力肯定强于印度运营商&#xff0c;但是中国用户不敢用&#xff0c;而印度用户敢用&#xff0c;这…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发