【数据结构】深入浅出理解快速排序背后的原理 以及 版本优化【万字详解】（C语言实现）

快速排序

  • 快速排序递归实现
  • 前言
  • 一、Hoare版本
  • （一）算法运行图例
  • （二）算法核心思路
  • （三）算法实现步骤
    • （1）单趟
    • （2）多趟
  • （四）码源详解 递归实现
    • （1）Hoare版本：先行版
    • （2）Hoare版本：发行版
  • （五）Hoare算法 实现背后的理论支持
  • （六）效率优化
    • Hoare排序的效率分析
    • （1）时间复杂度 O（N*logN）
    • 稳定性： 不稳定
  • （七）代码优化
  • （1）三数取中
    • 1）优化思路
  • 2）三数取中优化 后的代码
    • 3）效果对比
  • （2）小区间优化—— 小区间不再进行递归分割排序，降低递归次数
    • 1）优化思路
  • 2）整体优化后的完整代码
  • 二、挖坑法版本
  • 前言
  • （一）算法运行图例
  • （二）算法核心思路
  • （三）算法实现步骤
    • （1）单趟
    • （2）多趟
  • （四）码源详解
  • 三、前后指针版本
  • （一）算法运行图例
  • （二）算法核心思路
  • （三）算法实现步骤
    • （1）单趟
    • （2）多趟
  • （四）码源详解


快速排序递归实现

前言

快速排序是Hoare于1962年提出的一种 二叉树结构的交换排序方法。


一、Hoare版本


（一）算法运行图例

在这里插入图片描述


（二）算法核心思路

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合 分割成两子序列 ，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。


（三）算法实现步骤

（1）单趟

  1. 找一key 【注意：我们实际上控制的是key的下标keyi，而不是用新开辟的变量去储存它的值，用新开辟的变量去储存，最后交换的也只是与该变量进行交换，而不是在数组中与原数组的值进行交换】
    【图讲解】
  2. begin从左开始遍历，左边找比key大的。end从右开始遍历，右边找比key小的。等于key的值不动。
  3. 两边都找到了，互换
  4. 最后相遇的地方（就是key排好序后要放的位置（正确的位置））与key互换 【有理论支持的，请看下文】

此时 【左边的都比key小】中间key【右边的都比key大】
要是左右要是都有序 =》整体实现有序 （多趟解决）

（2）多趟

  1. 对排好的key的左边再进行单趟排序
  2. 对排好的key的右边再进行单趟排序
  3. 左边右边分别再排好两边key的位置，再分左右，再进行单趟

类似 二叉树前序递归的思想：根、左子树、右子树。


（四）码源详解 递归实现

（1）Hoare版本：先行版

按照思路写出来 了，大家看看都存在些什么问题。

//递归实现
// Hoare版本（先行版）
int PartSort1(DataType* a,int left,int right) {int key = a[left];          while (left < right) {     //相遇是跳出循环的条件     //right 先走if (a[key] < a[right]) {      right--;          }                                              //找到a[right]<a[keyi]的情况就停下if (a[left] < a[key]) {      //left 同理left++;}Swap(&a[left], &a[right]);       //都找到后互换}Swap(&a[left], &a[key]);//相遇后跳出循环 交换a[keyi]和left,right相遇的位置
}

  • 坑1：a[key] < a[right]，若a[key] 一直比 a[right]要小，则right则回一直向左right–遍历，则会出现越界的问题（同理left那边也是）

    • 解决方法：left<right,控制right不要越界，避免该序列本来就是有序（一直比a[keyi]要大而一直right–，越出边界的情况）的情况

  • 坑2：a[keyi] < a[right]，若不跳则要是两边都遇到相等的值，则两边无法再进入if（）语句进行right–或left++，而进入死循环

    • 解决方法：a[keyi]<=a[right]时，都跳

  • 坑3：int key = a[left]; Swap(&a[left], &a[key]); 真正在换的是哪个？
    key是局部变量，相当于在栈区开辟了一块空间，用于存储a[left]的值。实际与数组a[left]进行交换的，是局部变量这块空间里面的值，对数组原始的最左边并不产生任何影响

    • 解决方法：int left = keyi; 记录的应该是下标，通过控制下标来达到改变原数组

（2）Hoare版本：发行版

// Hoare版本（发行版）
int PartSort1(DataType* a, int left, int right) {int keyi = left;          //保存left的下标while (left < right) {     //相遇是跳出循环的条件     //right 先走if (left < right && a[keyi] <= a[right]) {      //left<right,控制right不要越界，避免该序列本来就是有序（一直比a[keyi]要大而一直right--，越出边界的情况）的情况right--;}                                              //找到a[right]<a[keyi]的情况就停下if (left < right && a[left] <= a[keyi]) {      //left 同理left++;}Swap(&a[left], &a[right]);       //都找到后互换}Swap(&a[left], &a[keyi]);//相遇后跳出循环 交换a[keyi]和left,right相遇的位置
}

（五）Hoare算法 实现背后的理论支持

★☆ 最后相遇的地方 就是key排好序后要放的位置（正确的位置）是怎么做到的呢？
右边先走做到的。
在这里插入图片描述

有了上面的理论保证，停下来的值一定比key小，才敢进行交换。

（六）效率优化

Hoare排序的效率分析

（1）时间复杂度 O（N*logN）

如果每次选到的 key=a[ left ] 都是中位数，这将会非常高效
【因为每单趟排好一次，key就能落入到其正确的位置】

  • 理想状态下是：满二叉树的分割【二分 O（N*logN）】

  • 而最差的情况：有序（接近有序）【每次取到的key都选到整个数组中次大或次小的数，每个key，left或right都要遍历一遍数组， O（N^2）】 但随机取的值肯定不是像这样有序（或接近有序）的（这种都是已经给你排好了的）

在这里插入图片描述

所以总体来说，Hoare在时间复杂度上是更接近于 O（N*logN） 的 。

稳定性： 不稳定


（七）代码优化

（1）三数取中

那么我们针对序列可能会出现最差情况（有序的情况），做一个程序优化——三数取中 。

1）优化思路

int mid=（left+right）/ 2 ；
对比 a[mid]、a[left]、a[right] 三个值，取值大小为中间的那个数 。【大大降低了取两边极端的可能，让取到的数更偏向于有序序列中间的数】

//三数取中 取的不是位置在中间的值，而是值大小位于中间的值
int Getmidi(DataType* a,int left,int right) {int mid = (left + right) / 2;//left mid rightif (a[left] < a[mid]) {if (a[mid] < a[right])       //mid为中间值return mid;else if (a[left] > a[right]) {    //mid为最大值return left;                  //left为中间值}else {return right;}}else { //a[left]>a[mid]if (a[mid] > a[right]) {         //mid为中间值return mid;}else if (a[left]<a[right]) {     //left为中间值，mid最小return left;}else {return right;}}}

2）三数取中优化 后的代码

//三数取中 取的不是位置在中间的值，而是值大小位于中间的值
int Getmidi(DataType* a,int left,int right) {int mid = (left + right) / 2;//left mid rightif (a[left] < a[mid]) {if (a[mid] < a[right])       //mid为中间值return mid;else if (a[left] > a[right]) {    //mid为最大值return left;                  //left为中间值}else {return right;}}else { //a[left]>a[mid]if (a[mid] > a[right]) {         //mid为中间值return mid;}else if (a[left]<a[right]) {     //left为中间值，mid最小return left;}else {return right;}}}// Hoare版本（发行版）
int PartSort1(DataType* a, int left, int right) {//三数取中int midi = Getmidi(a, left, right);Swap(&a[left], &a[midi]);   //交换a[left]与a[midi]值的位置     int keyi = left;          //保存left的下标while (left < right) {     //相遇是跳出循环的条件     //right 先走if (left < right && a[keyi] <= a[right]) {      //left<right,控制right不要越界，避免该序列本来就是有序（一直比a[keyi]要大而一直right--，越出边界的情况）的情况right--;}                                              //找到a[right]<a[keyi]的情况就停下if (left < right && a[left] <= a[keyi]) {      //left 同理left++;}//坑1：a[keyi] < a[right]，若不跳则要是两边都遇到相等的值，则两边无法再进入if（）语句进行right--或left++，而进入死循环//更正：a[keyi]<=a[right]时，都跳Swap(&a[left], &a[right]);       //都找到后互换}Swap(&a[left], &a[keyi]);//相遇后跳出循环 交换a[keyi]和left,right相遇的位置
}

3）效果对比

对 有序/接近有序 的序列中优化效果明显。
对 随机 就正常。
在这里插入图片描述


（2）小区间优化—— 小区间不再进行递归分割排序，降低递归次数

1）优化思路

满二叉树整体节点的个数：2^h-1（ 等比数列求和 ）。
最后一层的节点数就已经占了整体的 50% 。
最后三层的节点数就已经约占整体的 80% 的节点个数了 。

那么最后这三层约占整体80%的节点数，若采用递归的方式，将是对栈帧的一个很大的开销。因为我们最后这三层区间被分的比较小了，若采用更适用于小区间数排序的优化，无疑是对效率很大的提升！

那么小区间优化我们可以选择哪个小区间数排序方式呢？
希尔排序：数据大时比较有序（目的：让大的数更快的到后面去）
插入排序：少的数（最坏情况：逆序，比所有数都小）

因为小区间，数比较少，对比起来比较快，所以这里选择 插入排序 更快速便捷高效。
在这里插入图片描述

//小区间优化版本—— 小区间不再进行递归分割排序，降低递归次数
void QuickSort1(DataType* a, int begin, int end) {if (begin >= end)return;//10个数就已经占3层递归了，而递归层数中，尾三层所占节点的总数 约占80%，这尾三层再继续用递归的方法，而改用小区间数据排序优化的思路，能让程序整体得到进一步的优化if ((end - begin + 1) > 10) {int keyi = PartSort3(a, begin, end);QuickSort1(a, begin, keyi - 1);QuickSort1(a, keyi+1, end);}else {      //改用小区间数据优化排序InsertSort(a + begin, end - begin + 1);    // a+begin 找到对应数组所在的位置}
}

2）整体优化后的完整代码

//三数取中 取的不是位置在中间的值，而是值大小位于中间的值
int Getmidi(DataType* a,int left,int right) {int mid = (left + right) / 2;//left mid rightif (a[left] < a[mid]) {if (a[mid] < a[right])       //mid为中间值return mid;else if (a[left] > a[right]) {    //mid为最大值return left;                  //left为中间值}else {return right;}}else { //a[left]>a[mid]if (a[mid] > a[right]) {         //mid为中间值return mid;}else if (a[left]<a[right]) {     //left为中间值，mid最小return left;}else {return right;}}}// Hoare版本（发行版）
int PartSort1(DataType* a, int left, int right) {//三数取中int midi = Getmidi(a, left, right);Swap(&a[left], &a[midi]);   //交换a[left]与a[midi]值的位置     int keyi = left;          //保存left的下标while (left < right) {     //相遇是跳出循环的条件     //right 先走if (left < right && a[keyi] <= a[right]) {      //left<right,控制right不要越界，避免该序列本来就是有序（一直比a[keyi]要大而一直right--，越出边界的情况）的情况right--;}                                              //找到a[right]<a[keyi]的情况就停下if (left < right && a[left] <= a[keyi]) {      //left 同理left++;}//坑1：a[keyi] < a[right]，若不跳则要是两边都遇到相等的值，则两边无法再进入if（）语句进行right--或left++，而进入死循环//更正：a[keyi]<=a[right]时，都跳Swap(&a[left], &a[right]);       //都找到后互换}Swap(&a[left], &a[keyi]);//相遇后跳出循环 交换a[keyi]和left,right相遇的位置
}//小区间优化版本—— 小区间不再进行递归分割排序，降低递归次数
void QuickSort1(DataType* a, int begin, int end) {if (begin >= end)return;//10个数就已经占3层递归了，而递归层数中，尾三层所占节点的总数 约占80%，这尾三层再继续用递归的方法，而改用小区间数据排序优化的思路，能让程序整体得到进一步的优化if ((end - begin + 1) > 10) {int keyi = PartSort3(a, begin, end);QuickSort1(a, begin, keyi - 1);QuickSort1(a, keyi+1, end);}else {      //改用小区间数据优化排序InsertSort(a + begin, end - begin + 1);    // a+begin 找到对应数组所在的位置}
}

二、挖坑法版本

前言

挖坑法是Hoare排序的一个思路上的优化：不用再考虑为什么右边先走。
因为一开始的坑就在左边，那么一开始就得先从右边开始找，找比坑小的数。

（一）算法运行图例

在这里插入图片描述


（二）算法核心思路

和Hoare的思路一样，只不过这里是先挖好一个坑，再开始排。如果在左边挖坑，则从右边开始找；如果在右边挖坑，则从左边开始找。

（三）算法实现步骤

（1）单趟

  1. int key = a[left]; //保存好key值以后,左边形成第一个坑
  2. 右边先走，找小，填到左边的坑，右边形成新的坑
  3. 左边再走，找大，填到右边的坑，左边形成新的坑位
  4. left、right 相遇，跳出循环。最终相遇，一定在坑上相遇（因为left、right其中一个必在坑位上）且该坑位就是key值该在的有序序列中正确的位置（ 和Hoare版本的同理 ） 。将key保留的最开始坑位的值赋给现在left、right相遇所在的坑位。

（2）多趟

  1. 对排好的key的左边再进行单趟排序
  2. 对排好的key的右边再进行单趟排序
  3. 左边右边分别再排好两边key的位置，再分左右，再进行单趟

（四）码源详解

// 快速排序——挖坑法
int PartSort2(int* a, int left, int right) {//三数取中——取位值位于中间的值int midi = Getmidi(a, left, right);Swap(&a[left], &a[midi]);int key = a[left];      //保存好key值以后,左边形成第一个坑int hole = left; //单趟完成的返回的条件while (left < right) {//右边先走，找小，填到左边的坑，右边形成新的坑while (left < right && key <= a[right]) {right--;}a[hole] = a[right];hole = right;//左边再走，找大，填到右边的坑，左边形成新的坑位while (left < right && a[left] <= key) {left++;}a[hole] = a[left];hole = left;}//最后把储存的key的值填入坑位，不用怕坑位的数被覆盖，因为原坑位的数在这之前就已经赋到其他地方了a[hole] = key;return hole;      //返回已经排好正确位置的坑位位置}

三、前后指针版本

（一）算法运行图例

在这里插入图片描述


（二）算法核心思路

cur一直向前遍历，不管是遇到大的还是遇到小的。

而prev遇小的向前++，把小的交换过来；遇到大的就停下，等遇到小的时候就++将其交换覆盖。旨在把小的放其左边，大的放其右边。

cur越界后，遍历结束。此时 prev 所在的地方，正是key值该在的有序序列中正确的地方。

（三）算法实现步骤

（1）单趟

  1. 三数取中 _ 取中间值 赋给key
  2. int prev = left ; int cur = prev + 1;
    cur遇比key小的，交换Swap(&a[++prev],&a[cur]);（把小的放其左边）
  3. cur越界，遍历结束
  4. Swap ( &a[prev],&a[keyi] ); 此时 prev 所在的地方，正是key值该在的有序序列中正确的地方。

（2）多趟

  1. 对排好的key的左边再进行单趟排序
  2. 对排好的key的右边再进行单趟排序
  3. 左边右边分别再排好两边key的位置，再分左右，再进行单趟

（四）码源详解

  • 先行版
    这样写存在什么问题？
// 快速排序前后指针法 —— 先行版
int PartSort3(int* a, int left, int right) {int midi = Getmidi(a, left, right);Swap(&a[left], &a[midi]);int prev = left;int cur = prev + 1;int keyi = left;while (cur <= right) {     //cur越界结束while (cur <= right && a[cur] > a[keyi]) {      //没有碰到比key小的就一直向后遍历cur++;}//找到了++prev;                                         //遇小的了就++prev，Swap(&a[prev], &a[cur]);交换Swap(&a[prev], &a[cur]);}//cur越界后，代表遍历结束//在a[++prev] 的位置将key值赋予它（key该在的正确位置）Swap(&a[prev], &a[keyi]);return prev;
}

当cur一直没有再遇到小的，cur将会越界，而这仅会跳出内层（cur向后遍历）的循环，但程序仍在外层交换的循环中走。

所以cur越界后，程序仍要向下运行代码，这时交换的不再是数组中的数值，而是数组外后一位cur越界后位置的数值。
在这里插入图片描述

所以应不再进行交换。交换已经结束了。应跳出外层交换 a[prev] 和 a[cur] 的循环。进行下一步 a[prev] 与 a[keyi] 的交换，交换到key在有序中的正确位置。

  • 发行版（一）
    当判断出cur越界，即可break跳出循环，不再进行 a[prev] 与 a[cur] 的交换
// 快速排序前后指针法 —— 先行版
int PartSort3(int* a, int left, int right) {int midi = Getmidi(a, left, right);Swap(&a[left], &a[midi]);int prev = left;int cur = prev + 1;int keyi = left;while (cur <= right) {     //cur越界结束while (cur <= right && a[cur] > a[keyi]) {      //没有碰到比key小的就一直向后遍历cur++;}if (cur > right) {     //当判断出cur越界，即可break跳出循环，不再进行 a[prev] 与 a[cur] 的交换break;}//找到了++prev;                                         //遇小的了就++prev，Swap(&a[prev], &a[cur]);交换Swap(&a[prev], &a[cur]);}//cur越界后，代表遍历结束//在a[++prev] 的位置将key值赋予它（key该在的正确位置）Swap(&a[prev], &a[keyi]);return prev;
}

  • 发行版（二）
// 快速排序前后指针法
int PartSort3(int* a, int left, int right) {int midi = Getmidi(a, left, right);Swap(&a[left], &a[midi]);int prev = left;int cur = prev + 1;int keyi = left;while (cur <= right) {     //cur越界结束//写法一if (a[cur] < a[keyi]) {            Swap(&a[++prev],&a[cur]);    //在还没遇到大的之前，cur = prev + 1; a[++prev] = a[cur];数组自己与自己交换//遇小交换的意义：将比其小的值放左边，比其大的值放右边}//写法二if (a[cur] < a[keyi] && ++prev != cur); {    //如果不想要自己与自己交换的这种不必要的交换，++prev != cur条件也可以这么写Swap(&a[prev], &a[cur]);}cur++;}//cur越界后，代表遍历结束//在a[prev] 的位置将key值赋予它（key该在的正确位置）Swap(&a[prev],&a[keyi]); return prev;
}

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

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

相关文章

单元测试反射注解

单元测试反射注解

单元测试 就是针对最小的功能单元(方法)&#xff0c;编写测试代码对其进行正确性测试。 咱们之前是如何进行单元测试的&#xff1f;有啥问题 &#xff1f; Junit单元测试框架 可以用来对方法进行测试&#xff0c;它是由Junit公司开源出来的 具体步骤 Junit框架的常见注解…
阅读更多...
『亚马逊云科技产品测评』活动征文｜占了个便宜，12个月的免费云服务器

『亚马逊云科技产品测评』活动征文｜占了个便宜，12个月的免费云服务器

授权声明&#xff1a;本篇文章授权活动官方亚马逊云科技文章转发、改写权&#xff0c;包括不限于在 Developer Centre, 知乎&#xff0c;自媒体平台&#xff0c;第三方开发者媒体等亚马逊云科技官方渠道 在群里看到有小伙伴说亚马逊可以免费试用服务器&#xff0c;这种好事不得…
阅读更多...
Jenkins自动化部署简单配置

Jenkins自动化部署简单配置

下载安装jenkins 安装Jenkins步骤 点击Next的时候会有jdk版本跟Jenkins版本不符合的情况 1. 看下任务管理器内Jenkins服务是否启动&#xff0c;在浏览器里面输入localhost:2023&#xff08;端口号是安装时输入的&#xff09; 2. 根据路径找到放置密码的文件&#xff08;C…
阅读更多...
Yolov8改进CoTAttention注意力机制，效果秒杀CBAM、SE

Yolov8改进CoTAttention注意力机制，效果秒杀CBAM、SE

1.CoTAttention 论文地址&#xff1a;2107.12292.pdf (arxiv.org) CoTAttention网络是一种用于多模态场景下的视觉问答&#xff08;Visual Question Answering&#xff0c;VQA&#xff09;任务的神经网络模型。它是在经典的注意力机制&#xff08;Attention Mechanism&#xf…
阅读更多...
自动化测试中验证码问题如何解决？

自动化测试中验证码问题如何解决？

经常会被问到如何解决验证码的问题&#xff0c;在此记录一下我所知道的几种方式。 对于web应用来说&#xff0c;大部分的系统在用户登录时都要求用户输入验证码&#xff0c;验证码的类型的很多&#xff0c;有字母数字的&#xff0c;有汉字的&#xff0c;甚至还要用户输入一条算…
阅读更多...
让SOME/IP运转起来——SOME/IP系统设计（上）

让SOME/IP运转起来——SOME/IP系统设计（上）

什么是SOME/IP&#xff1f; SOME/IP&#xff08;Scalable service-Oriented MiddlewarE over IP&#xff09;是AUTOSAR应用层的协议&#xff0c;是基于IP协议的面向服务的可拓展性的中间件。 SOME/IP中主要定义了&#xff1a; 数据的序列化&#xff1a;SOME/IP支持的数据类型…
阅读更多...
Web开发介绍详细介绍

Web开发介绍详细介绍

Web开发介绍 1 什么是web开发 Web&#xff1a;全球广域网&#xff0c;也称为万维网(www World Wide Web)&#xff0c;能够通过浏览器访问的网站。 所以Web开发说白了&#xff0c;就是开发网站的&#xff0c;例如下图所示的网站&#xff1a;淘宝&#xff0c;京东等等 那么我们…
阅读更多...
SpringBoot集成JPA实现分页和CRUD

SpringBoot集成JPA实现分页和CRUD

SpringBoot集成JPA实现分页和CRUD 文章目录 SpringBoot集成JPA实现分页和CRUDpom.xmlapplication.propertiesaddCategory.jspeditCategory.jsphello.jsplistCategory.jspCategoryCategoryDAOCategoryServiceCategoryServiceImplPage4NavigatorRedisConfigCategoryControllerHel…
阅读更多...
基于Springboot+MYSQL+Maven实现的宠物医院管理系统（源码+数据库+运行指导文档+项目运行指导视频）

基于Springboot+MYSQL+Maven实现的宠物医院管理系统（源码+数据库+运行指导文档+项目运行指导视频）

一、项目简介 本项目是一套基于springboot框架实现的宠物医院管理系统 包含&#xff1a;项目源码、数据库脚本等&#xff0c;该项目附带全部源码可作为毕设使用。 项目都经过严格调试&#xff0c;eclipse或者idea 确保可以运行&#xff01; 该系统功能完善、界面美观、操作简单…
阅读更多...
【Kubernetes】初识k8s--扫盲阶段

【Kubernetes】初识k8s--扫盲阶段

文章目录 1、k8s概述2、为什么要有k8s2.1 回顾以往的应用部署方式2.2 容器具有的优势 3、k8s能带来什么 1、k8s概述 kubernetes是一个可移植、可扩展的开源平台&#xff0c;用于管理 容器化 的工作负载和服务&#xff0c;可促进申明式配置和自动化。kubernetes拥有一个庞大且快…
阅读更多...
ElasticSearch深度解析入门篇：高效搜索解决方案的介绍与实战案例讲解，带你避坑

ElasticSearch深度解析入门篇：高效搜索解决方案的介绍与实战案例讲解，带你避坑

ElasticSearch深度解析入门篇&#xff1a;高效搜索解决方案的介绍与实战案例讲解&#xff0c;带你避坑 1.Elasticsearch 产生背景 大规模数据如何检索 如&#xff1a;当系统数据量上了 10 亿、100 亿条的时候&#xff0c;我们在做系统架构的时候通常会从以下角度去考虑问题&a…
阅读更多...
【C语法学习】15 - fopen()函数

【C语法学习】15 - fopen()函数

文章目录 1 函数原型2 返回值3 参数3.1 文件名3.2 模式3.2.1 以"r"模式打开3.2.2 以"w"模式打开3.2.3 以"a"模式打开3.2.4 以"r"模式打开3.2.5 以"w"模式打开3.2.6 以"a"模式打开 1 函数原型 fopen()&#xff1a…
阅读更多...
右击显示Pycharm打开教程

右击显示Pycharm打开教程

效果图 操作流程 win r 输入 regedit 回车打开注册表编辑器 2.找到 shell 路径 计算机\HKEY_CLASSES_ROOT\Directory\shell3.在 shell 下新建项&#xff0c;名称为 Pycharm 单击Pycharm文件夹&#xff0c;双击默认项&#xff0c;修改默认值&#xff0c;这个数值就是你右击后…
阅读更多...
【Linux】 shutdown 命令使用

【Linux】 shutdown 命令使用

shutdown 命令可以用来进行关机程序&#xff0c;并且在关机以前传送讯息给所有使用者正在执行的程序&#xff0c;shutdown 也可以用来重开机。使用权限&#xff1a;系统管理者。 语法 shutdown [选项] 时间 [警告信息] 命令选项及作用 执行令 man shutdown 执行命令结果 参…
阅读更多...
计算虚拟化2——内存虚拟化

计算虚拟化2——内存虚拟化

目录 物理机内存访问过程 虚拟地址VA和物理地址PA概念 MUU实现VA到PA所使用的映射表 内存虚拟化类型 内存软件辅助虚拟化 内存硬件辅助虚拟化 内存虚拟化-内存超分配 内存共享 内存置换 内存气泡 物理机内存访问过程 内存的基本知识 内存都是从物理地址0开始的&…
阅读更多...
golang工程——opentelemetry简介、架构、概念、追踪原理

golang工程——opentelemetry简介、架构、概念、追踪原理

opentelemetry 简介 OpenTelemetry&#xff0c;简称OTel&#xff0c;是一个与供应商无关的开源可观测性框架&#xff0c;用于检测、生成、收集和导出 遥测数据&#xff0c;如轨迹、度量、日志。OTel的目标是提供一套标准化的供应商无关SDK、API和工具&#xff0c;用于接 收、…
阅读更多...
阿里云免费服务器

阿里云免费服务器

文章目录 最近的阿里云活动By the way在云服务器ECS上搭建个人网站正文补充:定期释放补充:不知道阿里云服务器的密码怎么办?成果补充&#xff1a;怎么找到实例操作的后台&#xff1f;补充&#xff1a;怎么查看服务器到期时间&#xff1f; 究竟白嫖了多少&#xff1f;最后&…
阅读更多...
[论文笔记]RetroMAE

[论文笔记]RetroMAE

引言 RetroMAE，中文题目为 通过掩码自编码器预训练面向检索的语言模型。 尽管现在已经在许多重要的自然语言处理任务上进行了预训练，但对于密集检索来说，仍然需要探索有效的预训练策略。 本篇工作，作者提出RetroMAE，一个新的基于掩码自编码器(Masked Auto-Encoder,MAE)…
阅读更多...
【leetcode】17.04 消失的数字

【leetcode】17.04 消失的数字

目录 1. 思路2. 代码 题目链接&#xff1a;leetcode 17.04.消失的数字 题目描述&#xff1a; 1. 思路 要求算法复杂度为O(n)&#xff0c;有两种方式&#xff1a; &#xff08;1&#xff09;利用异或交换律 与nums所有元素异或一遍&#xff1b;与0-n的值异或&#xff0c;n…
阅读更多...
开源 | 30余套STM32单片机、嵌入式Linux、物联网、人工智能项目(开发板+教程+视频)

开源 | 30余套STM32单片机、嵌入式Linux、物联网、人工智能项目(开发板+教程+视频)

文末免费领取&#xff01; 30余套综合项目案例 STM32单片机、嵌入式、物联网、人工智能 项目文档源码视频 高校教学、学生毕设、个人项目练手 嵌入式实战项目推荐 15个嵌入式LinuxQt综合应用项目&#xff0c;涉及家居、医疗、农业等多种应用领域&#xff0c;案例中使用了嵌…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023