【数据结构】7大排序最详细

0.前言

接下来进入排序，我们知道在c语言阶段可能就学习过了像冒泡排序，选择排序这种比较简单的排序，那么接下来我们就会学习到更加高级的排序算法。但高级代表着难度的提升，但不用担心，博主会细细来谈，慢慢品尝其中的酸甜苦辣。

1.排序的概念及其运用

1.1 排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

1.2 排序的运用

其实在我们生活中处处都需要排序，请看下面。

 

 它们都需要排序算法的支持才能呈现出我们想知道的排名情况。

这就可知排序算法的重要性。

1.3 常见的排序算法

 1.4 测试排序性能代码

这串代码可以测试我们的各个排序算法的性能大小。

计算结果是每个排序算法的启动到结束之间的毫秒差。

void TestOP()
{srand(time(0));const int N = 10000;int* a1 = (int*)malloc(sizeof(int) * N);int* a2 = (int*)malloc(sizeof(int) * N);int* a3 = (int*)malloc(sizeof(int) * N);int* a4 = (int*)malloc(sizeof(int) * N);int* a5 = (int*)malloc(sizeof(int) * N);int* a6 = (int*)malloc(sizeof(int) * N);int* a7 = (int*)malloc(sizeof(int) * N);for (int i = 0; i < N; ++i){a1[i] = rand();a2[i] = a1[i];a3[i] = a1[i];a4[i] = a1[i];a5[i] = a1[i];a6[i] = a1[i];a7[i] = a1[i];}int begin1 = clock();InsertSort(a1, N);int end1 = clock();int begin2 = clock();ShellSort(a2, N);int end2 = clock();int begin3 = clock();//SelectSort(a3, N);int end3 = clock();int begin4 = clock();//HeapSort(a4, N);int end4 = clock();int begin5 = clock();//QuickSort(a5, 0, N - 1);int end5 = clock();int begin6 = clock();//MergeSort(a6, N);int end6 = clock();int begin7 = clock();BubbleSort(a7, N);int end7 = clock();printf("InsertSort:%d\n", end1 - begin1);printf("ShellSort:%d\n", end2 - begin2);printf("SelectSort:%d\n", end3 - begin3);printf("HeapSort:%d\n", end4 - begin4);printf("QuickSort:%d\n", end5 - begin5);printf("MergeSort:%d\n", end6 - begin6);printf("BubbleSort:%d\n", end7 - begin7);free(a1);free(a2);free(a3);free(a4);free(a5);free(a6);free(a7);
}

 一道oj排序练习测试题，下面讲解的排序算法都可在上面训练：OJ链接

2.插入排序

2.1 基本思想

直接插入排序是一种简单的插入排序法，其基本思想是：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。
实际中我们玩扑克牌时，就用了插入排序的思想。

2.2 直接插入排序

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

代码：

void InsertSort(int* a, int n)
{//[0, end] end + 1for (int i = 0; i < n - 1; i++){int end = i;int tmp = a[end + 1];while (end >= 0){if (a[end] > tmp){a[end + 1] = a[end];end--;}else{break;}}a[end + 1] = tmp;}}


直接插入排序的特性总结：

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：O(N^2),最好情况下：O（N）--- 即当序列已经有序，只需要遍历一遍即可。
  3. 空间复杂度：O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定

2.3 希尔排序（缩小增量排序）

希尔排序法又称缩小增量法。希尔排序法的基本思想是：

先选定一个整数gap，把待排序文件中所有记录分成gap个组，所有距离为gap的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达gap=1时，所有记录在统一组内排好序。

代码： 

void ShellSort(int* a, int n)
{//预排序 --- 使序列逐渐接近有序//直接插入排序 --- gap == 1时即为直接插入排序int gap = n;while (gap > 1){//gap = gap / 2;gap = gap / 3 + 1;版本二for (int i = 0; i < n - gap; i++){int end = i;int tmp = a[end + gap];while (end >= 0){if (a[end] > tmp){a[end + gap] = a[end];end -= gap;}else{break;}}a[end + gap] = tmp;}}版本一/*for (int j = 0; j < gap; j++){for (int i = j; i < n - gap; i+=gap){int end = i;int tmp = a[end + gap];while (end >= 0){if (a[end] > tmp){a[end + gap] = a[end];end -= gap;}else{break;}}a[end + gap] = tmp;}}*/}

 希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定：我们通常把希尔排序的时间复杂度定为O（n^1.3）。
  4. 稳定性：不稳定。

3.选择排序

3.1 基本思想

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置（末尾位置），直到全部待排序的数据元素排完 。

3.2 直接选择排序

  • 在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素
  • 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
  • 在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

 代码：

void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}
void SelectSort(int* a, int n)
{int begin = 0, end = n - 1;while (begin < end){int mini = begin, maxi = begin;for (int i = begin + 1; i <= end; i++){if (a[i] < a[mini]){mini = i;}if (a[i] > a[maxi]){maxi = i;}}Swap(&a[begin], &a[mini]);if (maxi == begin){maxi = mini;}Swap(&a[end], &a[maxi]);begin++;end--;}
}

直接选择排序的特性总结：

  1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
  2. 时间复杂度：O(N^2)，最好情况也是O（N^2）
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

3.3 堆排序

  • 堆排序(HeapSort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。
  • 它是通过堆来进行选择数据。
  • 需要注意的是排升序要建大堆，排降序建小堆。
void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}
void AdjustDown(int* a, int size, int parent)
{int child = parent * 2 + 1;while (child < size){//假设左孩子大，如果假设错误，更新一下if (child + 1 < size && a[child + 1] > a[child]){child++;}if (a[child] > a[parent]){Swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 1;}else{break;}}
}
void HeapSort(int* a, int n)
{//建大堆 -- 升序//O(N)for (int i = (n - 1 - 1) / 2; i >= 0; i--){AdjustDown(a, n, i);}//交换//O(N*logN)int end = n - 1;while (end > 0){Swap(&a[end], &a[0]);AdjustDown(a, end, 0);end--;}}

 直接选择排序的特性总结：

  1. 堆排序使用堆来选数，效率就高了很多。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

4.交换排序

4.1 基本思想

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

4.2 冒泡排序

两两比较，大的冒到后面，小的留在前面。

代码：

void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}//时间复杂度:O(N^2)
//最好情况:O(N^2)
//加个exchange可以使最好情况变为O(N)
void BubbleSort(int* a, int n)
{for (int j = 0; j < n; j++){bool exchange = false;for (int i = 1; i < n - j; i++){if (a[i - 1] > a[i]){Swap(&a[i - 1], &a[i]);exchange = true;}}if (exchange == false){break;}}}

冒泡排序的特性总结：

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N^2) 最好情况下也是O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

4.3 快速排序

4.3.1hoare版本

 代码：

void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}
int GetMidi(int* a, int begin, int end)
{int midi = (begin + end) / 2;//两两比较if (a[begin] < a[midi]){if (a[midi] < a[end])return midi;else if (a[begin] > a[end])return begin;elsereturn end;}else{if (a[midi] > a[end])return midi;else if (a[begin] < a[end])return begin;elsereturn end;}
}
void QuickSort(int* a, int begin, int end)
{if (begin >= end)return;//三数取中int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int left = begin, right = end;int keyi = begin;while (left < right){//右边找小while (left < right && a[right] >= a[keyi]){right--;}//左边找大while (left < right && a[left] <= a[keyi]){left++;}Swap(&a[left], &a[right]);}Swap(&a[left], &a[keyi]);keyi = left;//[begin, keyi - 1] keyi [keyi + 1, end]QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);
}

 我们讲一下上面的代码，当然这已经是优化好了的完全版。

我们知道当left和right相遇时就将key位置与相遇位置互换，而key位置在相遇位置的左边呀，

我们为什么确定相遇位置的数一定比key位置的小呢?

先宣布一下答案，答案是因为右边先走的原因，

有两种情况：

1.R遇L：没有找到比key小的数，一直走，当与left相遇停止，此时是一定比key小的（因为左边已经全部遍历没有发现比key小的）

2.L遇R：R先走，找到小的停了下来，L找大，没有找到，遇到R停下，那么相遇位置比key小。

综上：相遇位置数一定比key位置数小 看来hoare版本的快排坑比较多，那么我们后来就对它进行了优化。

这种优化是思想上的优化，更易于我们理解。

4.3.2 挖坑法

 挖坑的基本思想就是挖出一个坑位，右边找小的放到坑位，右边就空出空位，然后左边找大放到右边的空位，左边又空出空位，最后相遇时把第一次挖出来的数放到相遇时的空位就结束。

int PartSort(int* a, int begin, int end)
{//三数取中int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int key = a[begin];int hole = begin;while (begin < end){//右边找小while (begin < end && a[end] >= key){end--;}a[hole] = a[end];hole = end;//左边找大while (begin < end && a[begin] <= key){begin++;}a[hole] = a[begin];hole = begin;}a[hole] = key;return hole;
}
void QuickSort(int* a, int begin, int end)
{if (begin >= end)return;int keyi = PartSort(a, begin, end);//[begin, keyi - 1] keyi [keyi + 1, end]QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);
}

4.3.3 前后指针版本

 前后指针，cur往后找小，prev紧跟着cur，找到小cur和prev都往后走，cur找到大，cur位置与prev位置交换，重复操作往后，直到cur越界，把key位置与prev位置交换，一趟结束。

int PartSort(int* a, int begin, int end)
{//三数取中int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int keyi = begin;int prev = begin;int cur = prev + 1;while (cur <= end){if (a[cur] < a[prev] && ++prev != cur){Swap(&a[cur], &a[prev]);}++cur;}Swap(&a[prev], &a[keyi]);keyi = prev;return keyi;
}void QuickSort(int* a, int begin, int end)
{if (begin >= end)return;int keyi = PartSort(a, begin, end);//[begin, keyi - 1] keyi [keyi + 1, end]QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);
}

4.3.4 快速排序优化

三数取中：

为什么我们要三数取中？

这是因为三数取中可以减少大量比较，原版的hoare版本，如果我们不进行三数取中在序列接近有序或已经是有序时，当我们选择key时就会选择一个比较小的数，那么每次找数都要将序列遍历一遍，因为key是在第一个位置，那么right必须要走到key位置才会停下来，这样的时间复杂度就是O（N^2）, 如果我们采取三数取中就会减少接近一半的找数的次数，近似二分的思想，这样的时间复杂度就是O(N*logN)。

 小区间优化：

由于在大量数据进行快排时是要进行很深的递归的，这就大大增加了消耗，我们知道vs2022有Debug版本和Relase版本，Relase版本下可能这个优化作用并不是很大，但Debug版本下就有一些提升，使得递归的深度减少，我们前面已经学习了二叉树，我们知道快排就是一种二叉树的递归形式，那么二叉树的最下层是数据占据总节点数的一半的，如果这些数据再全部继续递归，得不偿失，那我们可以让这些数据不再递归，而是进行插入排序即可，这就是小区间优化。

代码：

void QuickSort1(int* a, int begin, int end)
{if (begin >= end)return;if (end - begin + 1 <= 10){InsertSort(a + begin, end - begin + 1);}else{//三数取中int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int left = begin, right = end;int keyi = begin;while (left < right){//右边找小while (left < right && a[right] >= a[keyi]){right--;}//左边找大while (left < right && a[left] <= a[keyi]){left++;}Swap(&a[left], &a[right]);}Swap(&a[left], &a[keyi]);keyi = left;//[begin, keyi - 1] keyi [keyi + 1, end]QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);}
}

4.3.5 快速排序非递归版本

 快排的非递归版本就需要用到我们前面学到的栈了，用栈的压栈，出栈来代替我们递归时的函数调用，我们知道函数调用就是创建栈帧和销毁栈帧的过程，而我们造出来的数据结构的栈是在堆区开辟看空间，故不会有栈溢出的情况，这就是非递归的优势。

void QuickSortNonR(int* a, int begin, int end)
{ST s;STInit(&s);STPush(&s, end);STPush(&s, begin);while (!STEmpty(&s)){int left = STTop(&s);STPop(&s);int right = STTop(&s);STPop(&s);int keyi = PartSort(a, left, right);//[left keyi - 1] keyi [keyi + 1, right]if (left < keyi - 1){STPush(&s, keyi - 1);STPush(&s, left);}if (keyi + 1 < right){STPush(&s, right);STPush(&s, keyi + 1);}}STDestroy(&s);
}

 快速排序的特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(logN)
  4. 稳定性：不稳定

5.归并排序

5.1 基本思想

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：

 代码:

void _MergeSort(int* a, int begin, int end, int* tmp)
{if (begin >= end)return;int mid = (begin + end) / 2;// [begin, mid][mid+1, end]_MergeSort(a, begin, mid, tmp);_MergeSort(a, mid+1, end, tmp);// [begin, mid][mid+1, end]归并int begin1 = begin, end1 = mid;int begin2 = mid + 1, end2 = end;int i = begin;while (begin1 <= end1 && begin2 <= end2){if (a[begin1] < a[begin2]){tmp[i++] = a[begin1++];}else{tmp[i++] = a[begin2++];}}while(begin1 <= end1){tmp[i++] = a[begin1++];}while (begin2 <= end2){tmp[i++] = a[begin2++];}memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}void MergeSort(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail");return;}_MergeSort(a, 0, n - 1, tmp);free(tmp);
}

归并排序的特性总结：

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定 

6.排序算法时间复杂度及稳定性分析

7.选择题小练

1. 快速排序算法是基于（ ）的一个排序算法。
A分治法
B贪心法
C递归法
D动态规划法
2.对记录（54,38,96,23,15,72,60,45,83）进行从小到大的直接插入排序时，当把第8个记录45插入到有序表时，为找到插入位置需比较（ ）次？（采用从后往前比较）
A 3
B 4
C 5
D 6
3.以下排序方式中占用O（n）辅助存储空间的是
A 简单排序
B 快速排序
C 堆排序
D 归并排序
4.下列排序算法中稳定且时间复杂度为O(n2)的是（ ）
A 快速排序
B 冒泡排序
C 直接选择排序
D 归并排序
5.关于排序，下面说法不正确的是
A 快排时间复杂度为O(N*logN)，空间复杂度为O(logN)
B 归并排序是一种稳定的排序,堆排序和快排均不稳定
C 序列基本有序时，快排退化成冒泡排序，直接插入排序最快
D 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)
6.下列排序法中，最坏情况下时间复杂度最小的是（ ）
A 堆排序
B 快速排序
C 希尔排序
D 冒泡排序
7.设一组初始记录关键字序列为(65,56,72,99,86,25,34,66)，则以第一个关键字65为基准而得到的一趟快速排序结果是（）
A 34，56，25，65，86，99，72，66
B 25，34，56，65，99，86，72，66
C 34，56，25，65，66，99，86，72
D 34，56，25，65，99，86，72，66
答案：
1.A
2.C
3.D
4.B
5.D
6.A
7.A

8.总结

到这里排序这节就结束了，排序算法在我们生活中作用还是很大的，但理解它还是有一定难度的，但我们只要坚持把每一步了解清楚，一步一步攻克难关，最后都能很好的理解，希望多多支持！

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

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

相关文章

为什么要做FP独立站？FP独立站有哪些优势？

为什么要做FP独立站？FP独立站有哪些优势？

近年来&#xff0c;跨境电商的商家们面临越来越大的平台政策压力&#xff0c;商家们纷纷把眼光聚焦到独立站上&#xff0c;眼下独立站已经成为出海卖家的标配。 特别是想做FP商品的卖家&#xff0c;相对于亚马逊平台&#xff0c;独立站才是你们的最终出路... 那么&#xff0c;问…
阅读更多...
ROS2学习笔记一：安装及测试

ROS2学习笔记一：安装及测试

目录 前言 1 ROS2安装与卸载 1.1 安装虚拟机 1.2 ROS2 humble安装 2 ROS2测试 2.1 topic测试 2.2 小海龟测试 2.3 RQT可视化 2.4 占用空间 前言 ROS2的前身是ROS&#xff0c;ROS即机器人操作系统&#xff08;Robot Operating System&#xff09;,ROS为了“提高机器人…
阅读更多...
[有固件程序]车载液晶驱动板(RTD2660H)Fondar下载/烧录器工具v3使用说明

[有固件程序]车载液晶驱动板(RTD2660H)Fondar下载/烧录器工具v3使用说明

液晶屏幕驱动烧录器 FONDAR2IIC使用说明 介绍 RTD2660液晶屏幕FONDAR烧录器&#xff0c;可烧写液晶驱动板的固件程序&#xff0c;简单易上手&#xff0c;适合开发和个人DIY爱好者&#xff0c;更换不同屏幕烧写不同程序&#xff0c;提供固件仅供测试。 软件介绍 请在Windows 10…
阅读更多...
Delphi 11.3配置android环境

Delphi 11.3配置android环境

电脑安装dephi11.3的时候&#xff0c;勾选android sdk&#xff0c;但是软件安装好以后&#xff0c;还有问题 在Delphi—tool —options 里边&#xff0c;Deployment下SDKManager 中&#xff0c;看到SDk里边的感叹号&#xff0c;说明android sdk没有安装好 解决方法有2种 第一种…
阅读更多...
一键提取视频文字或者音频

一键提取视频文字或者音频

随着科技的进步&#xff0c;视频转文字技术已经变得越来越成熟&#xff0c;这种技术能够将视频中的语音转化为文字&#xff0c;为人们提供了极大的便利。水印云作为一款备受用户喜爱的在线视频转文字工具&#xff0c;凭借其高效、准确、易用的特点&#xff0c;在市场上占据了一…
阅读更多...
21款奔驰GLS450升级23P驾驶辅助 半自动无人驾驶功能

21款奔驰GLS450升级23P驾驶辅助 半自动无人驾驶功能

辅助驾驶越来越多的被大家所青睐&#xff01;为了提升驾驶安全性和舒适便捷性奔驰改装原厂半自动驾驶23P辅助系统&#xff0c;星骏汇小许Xjh15863 23P智能辅助驾驶系统还是很有必要的&#xff0c;因为在跑高速的时候可以使用23P智能驾驶的自动保持车速&#xff0c;保持车距&…
阅读更多...
【算法练习】leetcode算法题合集之回溯篇

【算法练习】leetcode算法题合集之回溯篇

组合问题 LeetCode39: 组合总和 LeetCode39. 组合总和 目标和&#xff0c;除了累加所有的数外还可以用目标值减去所有的数。 添加第i个元素后&#xff0c;可以继续添加第i个元素。可以添加第i个元素&#xff0c;也可以添加索引为candidates.length-1的元素 这类回溯的问题可以…
阅读更多...
CHS_01.1.3.1+操作系统的运行机制

CHS_01.1.3.1+操作系统的运行机制

CHS_01.1.3.1操作系统的运行机制 操作系统的运行机制 也就是说 操作系统在计算机上是怎么运行的这样一个问题 操作系统的运行机制 也就是说 操作系统在计算机上是怎么运行的这样一个问题 那这个小节中会涉及到这样的一些概念 我们会学习到两种类型的指令 然后两种处理机状态和两…
阅读更多...
【软件测试】刚入行的测试人，“我“该怎么提升自己技术能力...

【软件测试】刚入行的测试人，“我“该怎么提升自己技术能力...

目录&#xff1a;导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09; 前言 一个问题&#xf…
阅读更多...
【Helm 及 Chart 快速入门】03、Chart 基本介绍

【Helm 及 Chart 快速入门】03、Chart 基本介绍

目录 一、Chart 基本介绍 1.1 什么是 Chart 1.2 Chart ⽬录结构 1.3 Chart.yaml ⽂件 二、创建不可配置 Chart 2.1 创建 Chart 2.2 安装 Chart 三、创建可配置的 Chart 3.1 修改 chart 3.2 安装 Chart 一、Chart 基本介绍 1.1 什么是 Chart Helm 部署的应…
阅读更多...
LORA的基本原理

LORA的基本原理

本文将介绍如下内容&#xff1a; 什么是Lora高效微调的基本原理LORA的实现方式LORA为何有效&#xff1f; 一、什么是LoRA LoRA 通常是指低秩分解&#xff08;Low-Rank Decomposition&#xff09;算法&#xff0c;是一种低资源微调大模型方法&#xff0c;论文如下: LoRA: Low…
阅读更多...
大厂都在用的监控高可用方案，小公司还不赶紧学起来？

大厂都在用的监控高可用方案，小公司还不赶紧学起来？

有一次在一家国企时&#xff0c;他们是使用的dockernginx做为自己的“云”。同时&#xff0c;监控告警平台也不完善&#xff0c;虽然使用的是PrometheusGrafana&#xff0c;但仅仅是用来“看大屏”。 同时所有的报警都是一个一个的脚本去写的&#xff0c;例如写一个python脚本…
阅读更多...
卢森堡市场开发攻略，带你走进全球最富有的国家

卢森堡市场开发攻略，带你走进全球最富有的国家

卢森堡位于西欧&#xff0c;位于欧洲的十字路口&#xff0c;地理位置非常重要。卢森堡是高度发达的资本主义国家&#xff0c;人均gdp全球最高&#xff0c;是当之无愧的全球最富国家。卢森堡对外开放度高&#xff0c;很多产品依赖进口&#xff0c;也是一个非常不错的市场&#x…
阅读更多...
医疗门诊诊所预约挂号视频问诊小程序开发

医疗门诊诊所预约挂号视频问诊小程序开发

医疗门诊诊所预约挂号视频问诊小程序开发 医疗门诊诊所预约挂号视频问诊小程序开发 用户注册、登录&#xff1a;用户通过手机号注册、登录小程序账号&#xff0c;校验用户身份信息。预约挂号&#xff1a;用户选择就诊科室、日期和时间&#xff0c;预约医生门诊&#xff0c;并…
阅读更多...
【OpenCV学习笔记06】- 制作使用轨迹条控制的调色板

【OpenCV学习笔记06】- 制作使用轨迹条控制的调色板

这是对于 OpenCV 官方文档的 GUI 功能的学习笔记。学习笔记中会记录官方给出的例子&#xff0c;也会给出自己根据官方的例子完成的更改代码&#xff0c;同样彩蛋的实现也会结合多个知识点一起实现一些小功能&#xff0c;来帮助我们对学会的知识点进行结合应用。 如果有喜欢我笔…
阅读更多...
简单易懂的PyTorch线性层解析：神经网络的构建基石

简单易懂的PyTorch线性层解析：神经网络的构建基石

目录 torch.nn子模块Linear Layers详解 nn.Identity Identity 类描述 Identity 类的功能和作用 Identity 类的参数 形状 示例代码 nn.Linear Linear 类描述 Linear 类的功能和作用 Linear 类的参数 形状 变量 示例代码 nn.Bilinear Bilinear 类的功能和作用 B…
阅读更多...
申请Certum IP证书的方法

申请Certum IP证书的方法

Certum是波兰的一家数字证书颁发机构&#xff0c;可以为只有公网IP地址的网站提供IP证书的申请服务&#xff0c;为网站传输信息进行加密&#xff0c;提高网站SEO排名。Certum旗下的IP证书产品不多&#xff0c;其中比较受欢迎的就是DV基础型IP证书。今天就随SSL盾小编了解Certum…
阅读更多...
社交通证经济学：Web3时代的社交奖励系统

社交通证经济学：Web3时代的社交奖励系统

Web3时代的到来带来了区块链技术和去中心化的新范式&#xff0c;社交媒体也在这场变革中经历着深刻的改变。 社交通证经济学作为Web3时代社交媒体的创新实践&#xff0c;重新定义了用户在平台上的价值和奖励体系。本文将深入探讨Web3时代社交通证经济学的背景、工作原理以及对…
阅读更多...
最新版docker-compose安装

最新版docker-compose安装

Ubuntu/Kali 下载安装最新版 docker-compose # FastGit加速 sudo curl -L "https://hub.fgit.cf/docker/compose/releases/download$(curl -L -i -s -o /dev/null -w "%{url_effective}\n" https://hub.fgit.cf/docker/compose/releases/latest | awk -F tag …
阅读更多...
2024新年烟花代码完整版

2024新年烟花代码完整版

文章目录 前言烟花效果展示使用教程查看源码HTML代码CSS代码JavaScript 新年祝福 前言 在这个充满希望和激动的2024年&#xff0c;新的一年即将拉开帷幕&#xff0c;而数字科技的创新与发展也如火如荼。烟花绚丽多彩的绽放&#xff0c;一直以来都是新年庆典中不可或缺的元素。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023