排序算法教程（个人总结版）

1. 引言
1.1 什么是排序算法

排序算法是一类算法，用于将一组数据按特定顺序排列。常见的排序顺序有升序和降序。

1.2 排序算法的应用领域

排序算法在许多领域有广泛应用，如数据分析、数据库管理、信息检索、计算机图形学等。排序操作是计算机科学中基础性操作之一，对提高算法和系统的效率至关重要。

1.3 排序算法的分类

排序算法可以分为内部排序和外部排序。内部排序是在内存中进行排序，而外部排序是在外存中进行排序。此外，排序算法还可以按是否稳定分为稳定排序和不稳定排序。

2. 基本排序算法
2.1 冒泡排序

冒泡排序是一种简单的交换排序算法，通过多次遍历待排序数据，依次比较相邻元素并交换，将最大或最小的元素逐步“冒泡”到序列的一端。

算法实现：

module bubble_sort #(parameter N = 8) (input logic [31:0] data_in[N],output logic [31:0] data_out[N]
);logic [31:0] temp;int i, j;always_comb begindata_out = data_in;for (i = 0; i < N; i++) beginfor (j = 0; j < N-i-1; j++) beginif (data_out[j] > data_out[j+1]) begintemp = data_out[j];data_out[j] = data_out[j+1];data_out[j+1] = temp;endendendend
endmodule
2.2 选择排序

选择排序是一种简单的选择类排序算法，通过多次遍历待排序数据，选择最小（或最大）的元素放在序列的起始位置，逐步构建有序序列。

算法实现：

module selection_sort #(parameter N = 8) (input logic [31:0] data_in[N],output logic [31:0] data_out[N]
);logic [31:0] temp;int i, j, min_idx;always_comb begindata_out = data_in;for (i = 0; i < N; i++) beginmin_idx = i;for (j = i+1; j < N; j++) beginif (data_out[j] < data_out[min_idx]) beginmin_idx = j;endendif (min_idx != i) begintemp = data_out[i];data_out[i] = data_out[min_idx];data_out[min_idx] = temp;endendend
endmodule
2.3 插入排序

插入排序是一种简单的插入类排序算法，通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

算法实现：

module insertion_sort #(parameter N = 8) (input logic [31:0] data_in[N],output logic [31:0] data_out[N]
);logic [31:0] key;int i, j;always_comb begindata_out = data_in;for (i = 1; i < N; i++) beginkey = data_out[i];j = i - 1;while (j >= 0 && data_out[j] > key) begindata_out[j+1] = data_out[j];j = j - 1;enddata_out[j+1] = key;endend
endmodule
3. 高级排序算法
3.1 快速排序

快速排序是一种分治法排序算法，通过选择一个基准元素，将数组分为两部分，一部分所有元素比基准元素小，另一部分比基准元素大，递归地排序两个部分。

算法实现：

module quick_sort #(parameter N = 8) (input logic [31:0] data_in[N],output logic [31:0] data_out[N]
);function void quicksort(input int left, input int right);int i, j;logic [31:0] pivot, temp;if (left >= right) return;pivot = data_out[left + (right - left) / 2];i = left;j = right;while (i <= j) beginwhile (data_out[i] < pivot) i++;while (data_out[j] > pivot) j--;if (i <= j) begintemp = data_out[i];data_out[i] = data_out[j];data_out[j] = temp;i++;j--;endendquicksort(left, j);quicksort(i, right);endfunctionalways_comb begindata_out = data_in;quicksort(0, N-1);end
endmodule
3.2 归并排序

归并排序是一种稳定的分治法排序算法，通过将数组递归地分成两半，分别排序，然后合并两个有序数组。

算法实现：

module merge_sort #(parameter N = 8) (input logic [31:0] data_in[N],output logic [31:0] data_out[N]
);function void merge(input int left, input int mid, input int right);int i, j, k;int n1 = mid - left + 1;int n2 = right - mid;logic [31:0] left_arr[n1];logic [31:0] right_arr[n2];for (i = 0; i < n1; i++) left_arr[i] = data_out[left + i];for (j = 0; j < n2; j++) right_arr[j] = data_out[mid + 1 + j];i = 0;j = 0;k = left;while (i < n1 && j < n2) beginif (left_arr[i] <= right_arr[j]) begindata_out[k] = left_arr[i];i++;end else begindata_out[k] = right_arr[j];j++;endk++;endwhile (i < n1) begindata_out[k] = left_arr[i];i++;k++;endwhile (j < n2) begindata_out[k] = right_arr[j];j++;k++;endendfunctionfunction void mergesort(input int left, input int right);if (left < right) beginint mid = left + (right - left) / 2;mergesort(left, mid);mergesort(mid + 1, right);merge(left, mid, right);endendfunctionalways_comb begindata_out = data_in;mergesort(0, N-1);end
endmodule
3.3 堆排序

堆排序是一种基于堆数据结构的排序算法，通过构建一个最大堆或最小堆，将堆顶元素（最大或最小）与末尾元素交换，逐步调整堆结构。

算法实现：

module heap_sort #(parameter N = 8) (input logic [31:0] data_in[N],output logic [31:0] data_out[N]
);function void heapify(input int n, input int i);int largest = i;int left = 2*i + 1;int right = 2*i + 2;logic [31:0] temp;if (left < n && data_out[left] > data_out[largest])largest = left;if (right < n && data_out[right] > data_out[largest])largest = right;if (largest != i) begintemp = data_out[i];data_out[i] = data_out[largest];data_out[largest] = temp;heapify(n, largest);endendfunctionfunction void heapSort();int i;logic [31:0] temp;for (i = N / 2 - 1; i >= 0; i--)heapify(N, i);for (i = N - 1; i > 0; i--) begintemp = data_out[0];data_out[0] = data_out[i];data_out[i] = temp;heapify(i, 0);endendfunctionalways_comb begindata_out = data_in;heapSort();end
endmodule
4. 特殊排序算法
4.1 计数排序

计数排序是一种非比较排序算法，适用于元素取值范围较小的数组，通过计数每个元素出现的次数，然后按计数结果将元素放入输出数组。

算法实现：

module counting_sort #(parameter N = 8, parameter MAX_VAL = 100) (input logic [31:0] data_in[N],output logic [31:0] data_out[N]
);int count[MAX_VAL+1];int i;always_comb beginfor (i = 0; i <= MAX_VAL; i++) count[i] = 0;for (i = 0; i < N; i++) count[data_in[i]]++;for (i = 1; i <= MAX_VAL; i++) count[i] += count[i-1];for (i = N-1; i >= 0; i--) begindata_out[count[data_in[i]]-1] = data_in[i];count[data_in[i]]--;endend
endmodule
4.2 桶排序

桶排序是一种分布式排序算法，将数组元素分布到有限数量的桶中，对每个桶内的元素进行排序，然后合并所有桶中的元素。

算法实现：

module bucket_sort #(parameter N = 8, parameter NUM_BUCKETS = 10, parameter MAX_VAL = 100) (input logic [31:0] data_in[N],output logic [31:0] data_out[N]
);logic [31:0] buckets[NUM_BUCKETS][N];int bucket_count[NUM_BUCKETS];int i, j, k;function void insertion_sort_bucket(input int bucket_idx);logic [31:0] key;int m, n;for (m = 1; m < bucket_count[bucket_idx]; m++) beginkey = buckets[bucket_idx][m];n = m - 1;while (n >= 0 && buckets[bucket_idx][n] > key) beginbuckets[bucket_idx][n + 1] = buckets[bucket_idx][n];n = n - 1;endbuckets[bucket_idx][n + 1] = key;endendfunctionalways_comb beginfor (i = 0; i < NUM_BUCKETS; i++) bucket_count[i] = 0;for (i = 0; i < N; i++) beginint bucket_idx = data_in[i] * NUM_BUCKETS / (MAX_VAL + 1);buckets[bucket_idx][bucket_count[bucket_idx]++] = data_in[i];endfor (i = 0; i < NUM_BUCKETS; i++) beginif (bucket_count[i] > 0) begininsertion_sort_bucket(i);endendk = 0;for (i = 0; i < NUM_BUCKETS; i++) beginfor (j = 0; j < bucket_count[i]; j++) begindata_out[k++] = buckets[i][j];endendend
endmodule
4.3 基数排序

基数排序是一种非比较排序算法，适用于整数排序，通过按位（从最低位到最高位）进行排序，逐步构建有序数组。

算法实现：

module radix_sort #(parameter N = 8, parameter MAX_DIGITS = 10) (input logic [31:0] data_in[N],output logic [31:0] data_out[N]
);int count[10];logic [31:0] output[N];int i, digit, exp;function void counting_sort_digit(input int exp);for (i = 0; i < 10; i++) count[i] = 0;for (i = 0; i < N; i++) count[(data_in[i] / exp) % 10]++;for (i = 1; i < 10; i++) count[i] += count[i - 1];for (i = N - 1; i >= 0; i--) beginoutput[count[(data_in[i] / exp) % 10] - 1] = data_in[i];count[(data_in[i] / exp) % 10]--;endfor (i = 0; i < N; i++) data_in[i] = output[i];endfunctionalways_comb begindata_out = data_in;exp = 1;for (digit = 0; digit < MAX_DIGITS; digit++) begincounting_sort_digit(exp);exp = exp * 10;endend
endmodule
5. 排序算法的优化与改进
5.1 改进的冒泡排序

改进的冒泡排序通过在每一轮排序过程中记录最后一次交换的位置，减少不必要的比较和交换，从而提高排序效率。

算法实现：

module optimized_bubble_sort #(parameter N = 8) (input logic [31:0] data_in[N],output logic [31:0] data_out[N]
);logic [31:0] temp;int i, j, new_n;always_comb begindata_out = data_in;new_n = N;while (new_n > 0) beginint last_swap = 0;for (i = 1; i < new_n; i++) beginif (data_out[i-1] > data_out[i]) begintemp = data_out[i-1];data_out[i-1] = data_out[i];data_out[i] = temp;last_swap = i;endendnew_n = last_swap;endend
endmodule
5.2 改进的快速排序

改进的快速排序通过选择一个更好的基准元素（如三数取中法），以及在小规模数组时改用插入排序，提高排序效率。

算法实现：

module optimized_quick_sort #(parameter N = 8) (input logic [31:0] data_in[N],output logic [31:0] data_out[N]
);function logic [31:0] median_of_three(input int left, input int right);int mid = (left + right) / 2;if (data_out[left] > data_out[mid]){data_out[left], data_out[mid]} = {data_out[mid], data_out[left]};if (data_out[left] > data_out[right]){data_out[left], data_out[right]} = {data_out[right], data_out[left]};if (data_out[mid] > data_out[right]){data_out[mid], data_out[right]} = {data_out[right], data_out[mid]};{data_out[mid], data_out[right-1]} = {data_out[right-1], data_out[mid]};return data_out[right-1];endfunctionfunction void quicksort(input int left, input int right);int i, j;logic [31:0] pivot, temp;if (left + 10 <= right) beginpivot = median_of_three(left, right);i = left;j = right - 1;while (1) beginwhile (data_out[++i] < pivot);while (data_out[--j] > pivot);if (i < j) begintemp = data_out[i];data_out[i] = data_out[j];data_out[j] = temp;end else beginbreak;endendtemp = data_out[i];data_out[i] = data_out[right-1];data_out[right-1] = temp;quicksort(left, i - 1);quicksort(i + 1, right);end else begininsertion_sort(data_out[left:right+1]);endendfunctionalways_comb begindata_out = data_in;quicksort(0, N-1);end
endmodule
5.3 Timsort算法

Timsort是结合了归并排序和插入排序的混合排序算法，广泛应用于实际中，如Python的内置排序算法。

算法实现：

module timsort #(parameter N = 8, parameter MIN_RUN = 32) (input logic [31:0] data_in[N],output logic [31:0] data_out[N]
);function void insertion_sort(input int left, input int right);logic [31:0] key;int i, j;for (i = left + 1; i <= right; i++) beginkey = data_out[i];j = i - 1;while (j >= left && data_out[j] > key) begindata_out[j + 1] = data_out[j];j = j - 1;enddata_out[j + 1] = key;endendfunctionfunction void merge(input int left, input int mid, input int right);int i, j, k;int n1 = mid - left + 1;int n2 = right - mid;logic [31:0] left_arr[n1];logic [31:0] right_arr[n2];for (i = 0; i < n1; i++) left_arr[i] = data_out[left + i];for (j = 0; j < n2; j++) right_arr[j] = data_out[mid + 1 + j];i = 0;j = 0;k = left;while (i < n1 && j < n2) beginif (left_arr[i] <= right_arr[j]) begindata_out[k] = left_arr[i];i++;end else begindata_out[k] = right_arr[j];j++;endk++;endwhile (i < n1) begindata_out[k] = left_arr[i];i++;k++;endwhile (j < n2) begindata_out[k] = right_arr[j];j++;k++;endendfunctionalways_comb begindata_out = data_in;int size = MIN_RUN;for (int start = 0; start < N; start += MIN_RUN) beginint end = (start + MIN_RUN - 1 < N) ? start + MIN_RUN - 1 : N - 1;insertion_sort(start, end);endwhile (size < N) beginfor (int left = 0; left < N; left += 2 * size) beginint mid = (left + size - 1 < N) ? left + size - 1 : N - 1;int right = (left + 2 * size - 1 < N) ? left + 2 * size - 1 : N - 1;if (mid < right) merge(left, mid, right);endsize = 2 * size;endend
endmodule
6. 排序算法的应用
6.1 数据库排序

数据库排序用于对数据库中的记录进行排序，以便更高效地进行数据检索和管理。常用的排序方法包括B树排序、哈希排序等。

6.2 文件排序

文件排序用于对大文件进行排序，通常使用外部排序算法，如归并排序和多路归并排序。

6.3 内存排序与外部排序

内存排序适用于数据量较小的情况，在内存中进行排序；外部排序适用于数据量较大的情况，需要使用磁盘等外部存储设备。

7. 排序算法的性能分析
7.1 时间复杂度

时间复杂度用于衡量排序算法的运行时间随输入规模的增长情况。常见的时间复杂度有O(n^2)、O(n log n)等。

7.2 空间复杂度

空间复杂度用于衡量排序算法在运行过程中所需的额外空间。常见的空间复杂度有O(1)、O(n)等。

7.3 稳定性

稳定性是指排序算法在处理相等元素时，能否保持其相对顺序。稳定的排序算法包括插入排序、归并排序等，不稳定的排序算法包括快速排序、堆排序等。

8. 排序算法的优劣势对比
8.1 冒泡排序
  • 优势：实现简单，适用于小规模数据。
  • 劣势：时间复杂度高，为O(n^2)，不适用于大规模数据。
8.2 选择排序
  • 优势：实现简单，适用于小规模数据。
  • 劣势：时间复杂度高，为O(n^2)，不适用于大规模数据。
8.3 插入排序
  • 优势：实现简单，适用于小规模数据和部分有序数据。
  • 劣势：时间复杂度高，为O(n^2)，不适用于大规模数据。
8.4 快速排序
  • 优势：平均时间复杂度为O(n log n)，实际应用中表现良好。
  • 劣势：最坏情况下时间复杂度为O(n^2)，需要随机选择基准元素或改进算法以避免。
8.5 归并排序
  • 优势：时间复杂度为O(n log n)，稳定排序。
  • 劣势：空间复杂度较高，为O(n)，需要额外的存储空间。
8.6 堆排序
  • 优势：时间复杂度为O(n log n)，不需要额外空间。
  • 劣势：不稳定排序，实际应用中表现不如快速排序。
8.7 计数排序
  • 优势：时间复杂度为O(n+k)，适用于数据范围较小的情况。
  • 劣势：空间复杂度高，为O(k)，不适用于数据范围较大的情况。
8.8 桶排序
  • 优势：时间复杂度为O(n+k)，适用于数据分布均匀的情况。
  • 劣势：适用范围有限，需要分布均匀的数据。
8.9 基数排序
  • 优势：时间复杂度为O(nk)，适用于数据范围较大的情况。
  • 劣势：实现复杂，适用范围有限。
9. 总结与展望
9.1 排序算法的发展方向

随着计算技术的发展，排序算法在实际应用中展现出越来越强的求解能力和广泛的应用前景。未来的发展方向包括：

  • 混合排序算法：将多种排序算法结合，发挥各算法优势，提高求解效果。
  • 智能自适应算法：引入智能自适应机制，根据问题特性动态调整参数，提高算法适应性和求解效果。
  • 并行计算：利用并行计算技术，加速排序算法的求解过程，提高计算效率。
9.2 排序算法在大数据中的应用前景

随着大数据技术的发展，排序算法在大数据处理中的应用前景广阔，未来可能更多地采用分布式排序算法和并行排序算法，提高排序效率和处理能力。

结论

本教程详细介绍了各种排序算法的基本概念、实现方法及其在实际中的应用。通过这些内容，读者可以深入理解排序算法的原理，并灵活应用于不同场景中。在未来，随着技术的发展，排序算法将继续发挥其重要作用，推动各领域数据处理效率的提升。

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

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

相关文章

移植2D物理引擎到LVGL

移植2D物理引擎到LVGL

背景 在LVGL交流群&#xff0c;有网友提出想要移植物理引擎到LVGL&#xff0c;遂有了本文。阅读本文需要对IDF和LVGL有所了解 过程 2D物理引擎有很多&#xff0c;经过一番调研选择了Chipmunk2D 下载源码 此处省略一万字&#xff0c;Github访问可能会有些慢 添加文件 将…
阅读更多...
针对软件性能问题，如何定位解决？解决思路总结

针对软件性能问题，如何定位解决？解决思路总结

针对软件性能问题&#xff0c;我们可以按照以下步骤来定位和解决&#xff1a; 一、性能问题定位 响应时间分析&#xff1a; 响应时间是用户感知软件性能的重要指标之一。通过对系统的响应时间进行分析&#xff0c;可以定位到导致响应时间延长的关键路径。这些关键路径可能是数据…
阅读更多...
前端3剑客（第1篇）-初识HTML

前端3剑客（第1篇）-初识HTML

100编程书屋_孔夫子旧书网 当今主流的技术中&#xff0c;可以分为前端和后端两个门类。 前端&#xff1a;简单的理解就是和用户打交道 后端&#xff1a;主要用于组织数据 而前端就Web开发方向来说&#xff0c; 分为三门语言&#xff0c; HTML、CSS、JavaScript 语言作用HT…
阅读更多...
【Mysql语句优化---Explain使用以及相关属性含义】

【Mysql语句优化---Explain使用以及相关属性含义】

Explain使用以及相关属性含义 一.explain中的列 接下来我们将展示 explain 中每个列的信息。 1. id列 id列的编号是 select 的序列号&#xff0c;有几个 select 就有几个id&#xff0c;并且id的顺序是按 select 出现的顺序增长的。 id列越大执行优先级越高&#xff0c;id相…
阅读更多...
罗德里格斯旋转公式证明-简洁

罗德里格斯旋转公式证明-简洁

罗德里格斯旋转公式证明。 设旋转向量为 ( n , θ ) (n, \theta) (n,θ)&#xff0c;设其对应的旋转矩阵为 R R R&#xff0c; 如何证明&#xff1f; R c o s θ I n ∧ s i n θ ( 1 − c o s θ ) n n T Rcos\theta I n^{\wedge}sin\theta(1-cos\theta)nn^{T} RcosθI…
阅读更多...
什么是线性代数（Linear algebra）？

什么是线性代数（Linear algebra）？

什么是代数 代数的英文是Algebra&#xff0c;这个英文源自一个阿拉伯语“al jebr”&#xff0c;意思是 破碎部分的重新组合。这个意思促进了我代数的概念的理解。在代数中&#xff0c;我们会使用基本的算术&#xff08;加、减、乘、除&#xff09;&#xff0c;便是对于要处理的…
阅读更多...
红队内网攻防渗透：内网渗透之windows内网权限提升技术：用户篇

红队内网攻防渗透：内网渗透之windows内网权限提升技术：用户篇

红队内网攻防渗透 1. 内网权限提升技术1.1 内网安全-本地管理用户-权限提升1.2 本地管理用户-权限提升-服务启动（提权）1.3 本地管理用户-权限提升-远程控制（提权）1.4 本地管理用户-权限提升-进程注入（降权&提权）1.4.1 MSF-进程注入：1.4.1 CS-进程注入:1.5 本地管理用…
阅读更多...
[leetcode 9回文数]三行解决回文数问题

[leetcode 9回文数]三行解决回文数问题

9. 回文数 思路 将给定的整数x转换成字符串,再对字符串进行反转操作,最后比较两个字符串内容是否相等 java解法 class Solution {public boolean isPalindrome(int x) {String s String.valueOf(x);String reverse new StringBuffer(s).reverse().toString();return s.e…
阅读更多...
RDD与Java实战：学生列表，先按性别降序，再按年龄降序排列

RDD与Java实战：学生列表，先按性别降序，再按年龄降序排列

文章目录 Scala RDD 实现Java 实现实战总结 在本实战任务中&#xff0c;我们的目标是对学生列表进行排序&#xff0c;排序规则是先按性别降序排列&#xff0c;再按年龄降序排列。我们提供了两种实现方式&#xff1a;使用Scala的RDD&#xff08;弹性分布式数据集&#xff09;和…
阅读更多...
Yocto - bitbake任务中clean和cleanall的区别

Yocto - bitbake任务中clean和cleanall的区别

在 BitBake 中&#xff0c;clean 和 cleanall 命令都用于删除构建工件&#xff0c;但它们的范围和执行的清理程度不同。 1. clean 命令&#xff1a; 目的&#xff1a;clean命令用于删除与特定任务或配方相关的临时构建文件和工件。 范围&#xff1a;它只清除指定任务或配方生…
阅读更多...
Python 二叉数的实例化及遍历

Python 二叉数的实例化及遍历

首先创建一个这样的二叉树&#xff0c;作为我们今天的实例。实例代码在下方。 #创建1个树类型 class TreeNode:def __init__(self,val,leftNone,rightNone):self.valvalself.leftleftself.rightright #实例化类 node1TreeNode(5) node2TreeNode(6) node3TreeNode(7) node4Tre…
阅读更多...
Mybatis项目创建 + 规范

Mybatis项目创建 + 规范

文章目录 一、相关概念Mybatis1.1 什么是Mybatis1.1 如何实现简化JDBC 二、如何创建 Mybatis 项目2.1 创建SpringBoot项目 加载依赖2.2 准备数据库 以及 对象的映射2.3 配置数据库连接池2.4 使用Mybatis操作数据库2.5 单元测试 三、其他3.1 数据库与Java对象的映射规则 ---- 结…
阅读更多...
为什么GD32F303代码运行在flash比sram更快？

为什么GD32F303代码运行在flash比sram更快？

我们知道一般MCU的flash有等待周期&#xff0c;随主频提升需要插入flash读取的等待周期&#xff0c;以stm32f103为例&#xff0c;主频在72M时需要插入2个等待周期&#xff0c;故而代码效率无法达到最大时钟频率。 所以STM32F103将代码加载到sram运行速度更快。 但使用GD32F30…
阅读更多...
复习kafka

复习kafka

Kafka 介绍 Kafka 是一种分布式的&#xff0c;基于发布/订阅的消息系统。它最初由 LinkedIn 开发&#xff0c;并于 2011 年开源。Kafka 的设计目标是提供一种高效、可靠的消息传输机制&#xff0c;能够处理大量的实时数据。 Kafka 基本概念 Producer&#xff1a;生产者&#xf…
阅读更多...
Spring Boot 官方不再支持 Spring Boot 的 2.x 版本！新idea如何创建java8项目

Spring Boot 官方不再支持 Spring Boot 的 2.x 版本！新idea如何创建java8项目

idea现在只能创建最少jdk17 使用 IDEA 内置的 Spring Initializr 创建 Spring Boot 新项目时&#xff0c;没有 Java 8 的选项了&#xff0c;只剩下了 > 17 的版本 是因为 Spring Boot 官方不再支持 Spring Boot 的 2.x 版本了&#xff0c;之后全力维护 3.x&#xff1b;而 …
阅读更多...
阿里云计算之运维概念学习笔记（一）

阿里云计算之运维概念学习笔记（一）

运维管理 运维管理&#xff08;Operation and Maintenance Management, 简称O&M管理&#xff09;是指通过科学的管理方法和技术手段&#xff0c;对IT系统和基础设施进行监控、维护、优化和保障&#xff0c;以确保系统的高可用性、稳定性、安全性和性能。运维管理涵盖了硬件…
阅读更多...
ArcGIS属性域和子类型

ArcGIS属性域和子类型

01 属性域 道路的车道数值是小于10的。在编辑道路的此属性时&#xff0c;为了限制其值在10以内&#xff0c;可以使用属性域。当输入数据超过10时&#xff0c;就会限制输入。 限制输入这个功能是Pro特有的&#xff0c;在ArcMap中输入超出限制的值也是合法的&#xff0c;需要手动…
阅读更多...
【NOIP提高组】进制转换

【NOIP提高组】进制转换

【NOIP提高组】进制转换 &#x1f496;The Begin&#x1f496;点点关注&#xff0c;收藏不迷路&#x1f496; 我们可以用这样的方式来表示一个十进制数&#xff1a;将每个阿拉伯数字乘以一个以该数字所处位置的&#xff08;值减1&#xff09;为指数&#xff0c;以 10 为底数的幂…
阅读更多...
Mac硬件设备系统环境的升级/更新 macOS

Mac硬件设备系统环境的升级/更新 macOS

Mac硬件设备上进行系统环境的升级/更新macOS 1.大版本(升级)判断(比如&#xff1a;我买的这台电脑设备最高支持Monterey) 点击进入对应的大版本描述说明页查看相关的兼容性描述&#xff0c;根据描述确定当前的电脑设备最高可采用哪个大版本系统(Sonoma/Ventura/Monterey/Big Su…
阅读更多...
构建高效便捷的家政平台系统——打造优质家政服务的关键

构建高效便捷的家政平台系统——打造优质家政服务的关键

随着人们生活节奏的加快和工作压力的增大&#xff0c;家政服务的需求日益增长。为了满足这一需求&#xff0c;家政平台系统应运而生。本文将探讨家政平台系统的整体架构&#xff0c;以实现高效便捷的家政服务&#xff0c;打造优质家政体验。 ### 1. 家政平台系统背景 随着现代…
阅读更多...
最新文章

Copyright @ 2022~2023