数据结构 | 超详细讲解七大排序（C语言实现，含动图，多方法！）

目录

​编辑

排序的概念

常见排序算法

​编辑

1.冒泡排序

🍹图解

🥳代码实现

🤔时间复杂度

2.插入排序

🍹图解

🌴深度剖析

🍎代码思路

🥳代码实现

🤔时间复杂度

3.希尔排序

🌴深度剖析

🍎代码思路

🍋思考：关于gap的取值问题

🥳代码实现

🤔时间复杂度

4.堆排序

⛱️请看我的另一篇文章：详解堆排序

5.选择排序

🍹图解

🌴深度剖析

🥳代码实现

🤔时间复杂度

6.快速排序

🍹图解1：霍尔法

🌴深度剖析

🍎代码思路

🍎优化1：改变选key策略，采用三数选中法

🍎优化2：小区间优化，采用其它排序方法，减少递归次数

🍋思考：如何保证相遇位置比key小？

🥳代码实现

🍹图解2：前后指针法

 🌴深度剖析

🍎代码思路

🍎优化：避免自己和自己交换

🥳代码实现

🍹非递归实现

🍎代码思路

🥳代码实现

7.归并排序

🍹图解

🌴深度剖析

🍹递归版

🍎代码思路

🥳代码实现

🍹非递归版

🍎代码思路

🍋思考：上面的思路只能解决数组大小为的数组，其余数组则会存在越界问题，如何解决？

🥳代码实现

🤔时间复杂度

排序的概念

排序 ：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性 ：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次
序保持不变，即在原序列中， r[i]=r[j] ，且 r[i] 在 r[j] 之前，而在排序后的序列中， r[i] 仍在 r[j] 之前，则称这种排
序算法是稳定的；否则称为不稳定的。
内部排序 ：数据元素全部放在内存中的排序。
外部排序 ：数据元素太多不能同时放在内存中，根据排序过程的要求不断地在内外存之间移动数据的排序。

常见排序算法

下文将会细细介绍上图中七种排序，观看前，可以点一个免费的赞与收藏支持作者~希望本篇博客能帮助到你！

1.冒泡排序

相邻两个数进行比较，大的数向后移，每次循环都能冒出一个大的数到数组最后，直至最后全部冒出。

🍹图解

🥳代码实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>void bubble_sort(int arr[],int sz)
{int flag = 1;//优化int i = 0;for (i = 0; i < sz - 1; i++) {int j = 0;for (j = 0; j < sz - 1 - i; j++) {if (arr[j] > arr[j + 1]) {flag = 0;int tmp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = tmp;}}if (flag == 1) {break;}}
}int main() {int n = 0;int arr[] = {2,6,9,3,6,9,1};int sz = sizeof(arr) / sizeof(arr[0]);bubble_sort(arr, sz);for (n = 0; n < sz - 1; n++) {printf("%d", arr[n]);}return 0;
}

🤔时间复杂度

O(N^2)

2.插入排序

🍹图解

🌴深度剖析

🍎代码思路

上图为基本的插入排序，可对其进行优化：依次遍历找出最大值和最小值索引。

代码思路：1.设变量mini，maxi分别为最小值和最大值索引

                     设begin，end分别无序部分的首尾索引。

                  2.遍历无序部分，找出最小值和最大值的索引mini，maxi

                  3.将a[begin]和a[mini]进行交换，将a[end]和a[maxi]进行交换

                     注意：两次交换的中间需要进行依次判断，判断maxi是否仍然等于begin，因为经过第一个交换后原begin位置的值已经交换到mini位置去了，如果判断成立，maxi也应该跟随原begin的值的移动移动到mini位置。

                  4.此时begin、end处已经属于有序部分，begin++,end--，，更新无序部分的范围。

                 5.对剩余无序部分重复上述步骤，直到begin==end。

🥳代码实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void swap(int* a, int* b) {int tmp = *a;*a = *b;*b = tmp;
}void selectsort(int* a, int n) {int begin = 0;int end = n - 1;while (begin < end) {int mini = begin;int 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[mini], &a[begin]);if (maxi == begin)//begin此时被mini换走了maxi = mini;swap(&a[maxi], &a[end]);begin++;end--;}}int main() {int a1[8] = { 9,1,2,5,7,4,6,3};selectsort(a1,8);//int a2[5] = { 3,2,5,6,7 };//selectsort(a2, 5);for (int i = 0; i < 8; i++) {printf("%d ", a1[i]);}return 0;
}

🤔时间复杂度

O（N^2)

3.希尔排序

🌴深度剖析

🍎代码思路

希尔排序是在插入排序的基础上进行优化的。

1.预排序：将数组分为gap组，进行预排序（让数组接近有序）

2.插入排序（此时，数组近乎有序，使用插入排序效率极高）

即蓝色的为一组，红色的为一组，绿色为一组，对每组进行插入排序

以下是预排序的代码：

//预排序过程，假设gap=3
//第一种写法：依次对三组进行预排序
for(int j=0;j<gap;j++){   //依次对三组进行预排序
for (int i = gap; i < n; i+=gap) {  //对一组进行预排序的过程，由于一组内部元素之间相距gap，所以应该是i+=gapint end = i;int tmp = a[end];while (end >= gap) {if (tmp < a[end - gap]) {a[end] = a[end - gap];a[end - gap] = tmp;end -= gap;}else {break;}} }
//第二种写法：同时进行三组的预排序（但效率相较上一种写法其实没有改变）
for (int i = gap; i < n; i++) {//先对蓝组排1下，再对红组排1下，再对绿组排1下，如此循环int end = i;int tmp = a[end];while (end >= gap) {if (tmp < a[end - gap]) {a[end] = a[end - gap];a[end - gap] = tmp;end -= gap;}else {break;}}

🍋思考：关于gap的取值问题

gap越大：大的数字越快跳到后面，小的数字越快跳到前面，结果越不接近有序。

gap越小：跳得越慢，但结果越接近有序（gap==1时，相当于插入排序)

解决方案：走多组gap，gap>1时就是预排序

                                      gap==1时就是插入排序

gap我们通常设置为gap=gap/3+1

这里＋1是为了保证gap>=1。

🥳代码实现

//1.预排序，分成gap组进行//2.插入排序void ShellSort(int* a, int n) {int gap = n;while (gap>1) {gap = gap / 3 + 1;//保证gap>=1for (int i = gap; i < n; i++) {int end = i;int tmp = a[end];while (end >= gap) {if (tmp < a[end - gap]) {a[end] = a[end - gap];a[end - gap] = tmp;end -= gap;}else {break;}}}}}

🤔时间复杂度

4.堆排序

⛱️

请看我的另一篇文章：详解堆排序

5.选择排序

🍹图解

🌴深度剖析

基本思路：遍历一遍，选择最小的插到最左边

优化思路：遍历一遍，选出最小的最大的分别插到最左最右

一个小坑：将最大值放到最后后，可能破坏了原本的

🥳代码实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void swap(int* a, int* b) {int tmp = *a;*a = *b;*b = tmp;
}void selectsort(int* a, int n) {int begin = 0;int end = n-1 ;while (begin < end) {int mini = a[begin];int maxi = a[end];for (int i = begin; i <= end; i++) {if (a[i] < mini) {mini = a[i];swap(&a[i], &a[begin]);}if(a[i]>maxi) {maxi = a[i];swap(&a[i], &a[end]);}//验证if (a[i] <= mini) {mini = a[i];swap(&a[i], &a[begin]);}}begin++;end--;}}int main() {int a1[8] = { 9,1,2,5,7,4,6,3};selectsort(a1,8);//int a2[5] = { 3,2,5,6,7 };//selectsort(a2, 5);for (int i = 0; i < 8; i++) {printf("%d ", a1[i]);}return 0;
}

🤔时间复杂度

O（N^2)

6.快速排序

🍹图解1：霍尔法

🌴深度剖析

🍎代码思路

我们先考虑单趟：
    end,begin相遇前：end向前走找比key小的值，begin向后走找比key大的值，都找到后两者进行交换
    end,begin相遇时：循环停止，交换begin和key

  单趟过后的结果：

key所在位置一定是正确的位置，[left,key-1]中的值一定小于key，[key+1,right]中的值一定大于key

//单趟（一定先走end,再走begin）
int begin = left;int end = right;int key = left;while (begin < end) {while (a[end] >= a[key] && begin < end) {end--;}while(a[begin] <= a[key]&&begin<end) {begin++;}Swap(&a[begin], &a[end]);}Swap(&a[begin], &a[key]);
key = begin;

此时整个数组可以划分为三个部分：[left,key-1]，key,   [key+1,right]

递归：接着就用递归思想对[left,key-1]，[key+1,right]中的值进行排序
  递归结束条件：数组不存在或者只有1个元素

🍎优化1：改变选key策略，采用三数选中法

当数组有序排列时，且数据量较大时，基础版快排可能出现栈溢出问题。

解决办法:改变选key的策略，采用三数选中的方法，使key不要老是为最小值，而尽量趋于中值。

即确定出三个索引，如left，right, (right-left)/2，选出三个索引对应的值为中值的索引。

//优化1：改变选key的策略，采用三数选中法
int FindMid(int* a, int left, int right) {int mid = (left + right) / 2;if (a[left] < a[right]) {if (a[left] < a[mid]) {if (a[mid] < a[right]) {//a[left]<a[mid]<a[right]return mid;}else {//a[left]<a[right]<a[mid]return right;}}else {//a[mid]<a[left]<a[right]return left;}}else {//a[left] > a[right]if (a[mid] > a[right]) {if (a[mid] > a[left]) {//a[mid] > a[left]> a[right]return left;}else {return mid;}}else {//a[left] > a[right]>a[mid]return right;}}
}

🍎优化2：小区间优化，采用其它排序方法，减少递归次数

冒泡排序、选择排序效率太一般，希尔排序更适合处理数据量更大的数据，此时的数据已经较为接近有序，此处采用插入排序。

	//优化：小数区间，采取选择排序if (left + 5 >= right) {InsertSort(a+left, right - left + 1);return;}

🍋思考：如何保证相遇位置比key小？

左边做key，右边先走，可以保证相遇位置比key小。

相遇场景分析：

begin遇end：end先走，停下来，一定是因为遇到了比key小的值。

                      begin再走，begin没有找到大的遇到end就停下了。

end遇begin：end走，end没有找到小的遇到begin就停下了。

                      而begin的位置此时还是上一轮交换的位置，而上一轮交换，把比key小的值换到了begin的位置。

🥳代码实现

1.基础版（递归）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//递归版
void Swap(int* a, int* b) {int tmp = *a;*a = *b;*b = tmp;
}
void QuickSort(int* a, int left, int right) {//先考虑单趟//end找比key小，begin找比key大，都找到后交换//end,begin相遇时停止，交换begin和key//单趟过后的结果：key所在位置一定是正确的位置，a[left,key-1]一定小于key，a[key+1,right]一定大于key//接着就用递归思想处理：a[left,key-1]，a[key+1,right]//递归结束条件：数组不存在或者只有1个元素if (left >= right) {return;}int begin = left;int end = right;int key = left;while (begin < end) {while (a[end] >= a[key] && begin < end) {end--;}while(a[begin] <= a[key]&&begin<end) {begin++;}Swap(&a[begin], &a[end]);}Swap(&a[begin], &a[key]);key = begin;//此时key需要改变QuickSort(a, left, key-1);QuickSort(a, key + 1,  right);
}int main() {int a[10]={ 6, 1, 2, 7, 9, 3, 4, 5, 10,8 };QuickSort(a, 0, 9);for (int i = 0; i < 10; i++) {printf("%d ", a[i]);}return 0;
}

2.优化版（递归）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//递归版
void Swap(int* a, int* b) {int tmp = *a;*a = *b;*b = tmp;
}
//优化1：改变选key的策略，采用三数选中法
int FindMid(int* a, int left, int right) {int mid = (left + right) / 2;if (a[left] < a[right]) {if (a[left] < a[mid]) {if (a[mid] < a[right]) {//a[left]<a[mid]<a[right]return mid;}else {//a[left]<a[right]<a[mid]return right;}}else {//a[mid]<a[left]<a[right]return left;}}else {//a[left] > a[right]if (a[mid] > a[right]) {if (a[mid] > a[left]) {//a[mid] > a[left]> a[right]return left;}else {return mid;}}else {//a[left] > a[right]>a[mid]return right;}}
}void InsertSort(int* a, int n) {for (int i = 1; i < n ; i++) {int end = i;int tmp = a[end];while (end > 0) {if (tmp < a[end - 1]) {a[end] = a[end - 1];a[end - 1] = tmp;end--;}else {break;}}}
}void QuickSort(int* a, int left, int right){//先考虑单趟//end找比key小，begin找比key大，都找到后交换//end,begin相遇时停止，交换begin和key//单趟过后的结果：key所在位置一定是正确的位置，a[left,key-1]一定小于key，a[key+1,right]一定大于key//接着就用递归思想处理：a[left,key-1]，a[key+1,right]//递归结束条件：数组不存在或者只有1个元素/*if (left >= right) {return;}*///优化：小数区间，采取选择排序if (left + 5 >= right) {InsertSort(a+left, right - left + 1);return;}int begin = left;int end = right;//优化：改变选key的策略，采用三数选中法int key = FindMid(a+left, left, right);Swap(&a[begin], &a[key]);key = begin;//int key = begin;while (begin < end) {while (a[end] >= a[key] && begin < end) {end--;}while(a[begin] <= a[key]&&begin<end) {begin++;}Swap(&a[begin], &a[end]);}Swap(&a[begin], &a[key]);key = begin;//此时key需要改变QuickSort(a, left, key-1);QuickSort(a, key + 1,  right);
}int main(){int a[10]={ 6, 1, 2, 7, 9, 3, 4, 5, 10,8 };QuickSort(a, 0, 9);for (int i = 0; i < 10; i++) {printf("%d ", a[i]);}return 0;
}

🍹图解2：前后指针法

 🌴深度剖析

🍎代码思路

仍然从单趟开始分析：

1.

2.判断cur指针指向的数据是否小于key：

  小于——prev后移一位，交换cur和prev指向的内容，cur指针后移一位

大于——cur后移一位，效果：使得prev和cur之间的值全是大于key的值

3.当cur越界，将prev指向的内容与key进行呼唤

效果：key左边的数据都比key小，key右边的数据都比key大

由于快慢指针法单趟后的效果和霍尔法其实是一致的，后续步骤就和霍尔法的步骤一模一样。

🍎优化：避免自己和自己交换

if (a[cur] < a[key] && ++prev != cur) {//优化：当++prev与cur重叠时，就不进行交换Swap(&a[cur], &a[prev]);}

🥳代码实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void Swap(int* a, int* b) {int tmp = *a;*a = *b;*b = tmp;
}
//优化1：改变选key的策略，采用三数选中法
int FindMid(int* a, int left, int right) {int mid = (left + right) / 2;if (a[left] < a[right]) {if (a[left] < a[mid]) {if (a[mid] < a[right]) {//a[left]<a[mid]<a[right]return mid;}else {//a[left]<a[right]<a[mid]return right;}}else {//a[mid]<a[left]<a[right]return left;}}else {//a[left] > a[right]if (a[mid] > a[right]) {if (a[mid] > a[left]) {//a[mid] > a[left]> a[right]return left;}else {return mid;}}else {//a[left] > a[right]>a[mid]return right;}}
}void InsertSort(int* a, int n) {for (int i = 1; i < n; i++) {int end = i;int tmp = a[end];while (end > 0) {if (tmp < a[end - 1]) {a[end] = a[end - 1];a[end - 1] = tmp;end--;}else {break;}}}
}void QuickSort2(int* a, int left, int right) {if (left + 5 >= right) {InsertSort(a + left, right - left + 1);return;}//优化：改变选key的策略，采用三数选中法int key = FindMid(a + left, left, right);Swap(&a[left], &a[key]);key = left;int prev = left;int cur = left + 1;while (cur <= right) {if (a[cur] < a[key] && ++prev != cur) {//优化：当++prev与cur重叠时，就不进行交换Swap(&a[cur], &a[prev]);}cur++;}Swap(&a[key], &a[prev]);key = prev;//此时key需要改变QuickSort2(a, left, key - 1);QuickSort2(a, key + 1, right);
}int main(){int a[10] = { 6, 1, 2, 7, 9, 3, 4, 5, 10,8 };QuickSort2(a, 0, 9);for (int i = 0; i < 10; i++) {printf("%d ", a[i]);}return 0;
}

🍹非递归实现

🍎代码思路

利用栈来模拟递归的过程，假设每次key值都刚好二分。

1.初始化一个栈，将right和left压入栈中

1.对数组进行单趟快速排序，得到[left,key-1],key,[key+1,right]

2.设begin1=left，end1=key-1

   设begin2=key+1，end2=right

3.若begin2<end2,将end2，begin2压入栈中

若begin1<end1,将end1，begin1压入栈中

4.取并删除栈顶元素两次，得到begin1，end1，对[begin1,end1]数组进行单趟快速排序

5.重复步骤2，3,4,栈为空时循环结束

.

🥳代码实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include "stack.h"void Swap(int* a, int* b) {int tmp = *a;*a = *b;*b = tmp;
}void QuickSort(int* a, int left, int right) {Stack st;StackInit(&st);StackPush(&st, right);StackPush(&st, left);while (!StackEmpty(&st)) {left = StackTop(&st);StackPop(&st);right = StackTop(&st);StackPop(&st);int begin = left;int end = right;int key = begin;while (begin < end) {while (a[end] >= a[key] && begin < end) {end--;}while (a[begin] <= a[key] && begin < end) {begin++;}Swap(&a[begin], &a[end]);}Swap(&a[begin], &a[key]);key = begin;//此时key需要改变int begin1 = left;int end1 = key - 1;int begin2 = key + 1;int end2 = right;if (begin2 < end2) {StackPush(&st, end2);StackPush(&st, begin2);}if (begin1 <end1) {StackPush(&st, end1);StackPush(&st, begin1);}}StackDestroy(&st);return;
}int main() {int a[10] = { 6, 1, 2, 7, 9, 3, 4, 5, 10,8 };QuickSort(a, 0, 9);for (int i = 0; i < 10; i++) {printf("%d ", a[i]);}return 0;
}

7.归并排序

🍹图解

🌴深度剖析

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

🍹递归版

🍎代码思路

假设数组可以被拆分成两个子数组：

比较begin1和begin2位置的值，

取小尾插到tmp，

被取指针向前移动

未被取指针，不动

但问题是：数组往往不能直接被拆成两个有序数组

因此，考虑继续细分数组直到有序（比如只有1个数时必定有序）

然后将有序子数组一层层的合并回去，每次合并完将结果拷贝回原数组。

这个过程有点类似后序遍历。

🥳代码实现

void MergeSort1(int* a, int n) {int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL) {perror("tmp malloc fail!");return;}if (n <= 1) {//当数组被拆分成单个数，或无法继续拆分，返回return;}int mid = (n+1)/ 2;//假设数组3个数，mid==2,MergeSort1(a, mid);//[0,mid-1]有序MergeSort1(a+mid, n-mid);//[mid,n-1]有序//合并两个有序数组int begin1 = 0;int end1 = mid - 1;int begin2 = mid;int end2 = n - 1;int tmp1 = 0;while (begin1 <=end1 && begin2 <= end2) {if (a[begin1] < a[begin2]) {//begin1的数比begin2小，尾插begin1tmp[tmp1] = a[begin1];begin1++;tmp1++;}else {tmp[tmp1] = a[begin2];begin2++;tmp1++;}}//循环结束，说明有一方指针已经走完//将另一方未走完指针走完while (begin1 <=end1) {tmp[tmp1] = a[begin1];begin1++;tmp1++;}while (begin2 <=end2) {tmp[tmp1] = a[begin2];begin2++;tmp1++;}//此时的tmp数组为有序数组//拷贝回原数组memcpy(a, tmp, sizeof(int) * n);
}

🍹非递归版

🍎代码思路

1.首先设一个变量gap代表每组需要归并的个数。

2.划分两个大小为gap的子数组[begin1,end1],[begin2,end2]，这两个数组应当是有序的，对其进行归并，归并完后，继续向后划分两个大小为gap的子数组，继续归并，直到整个数组被遍历完。

3.遍历完一次数组意味着以gap*2为大小的子数组已经有序，因此gap*=2，以新gap数，继续完成新一轮对数组的归并遍历。直到gap>=2,结束。

🍋思考：上面的思路只能解决数组大小为2^n的数组，其余数组则会存在越界问题，如何解决？

这是一个数据个数为10的数组：

打印每轮的合并情况，可发现，有些位置发生了越界：

将图示越界的位置抽象出来，即为：

解决方案：

判断begin2是否存在，若不存在，则结束归并，若存在则修正end2，使其不越界。

🥳代码实现

void MergeSort2(int* a, int n) {int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL) {perror("tmp malloc fail!");return;}if (n <= 1) {//当数组被拆分成单个数，或无法继续拆分，返回return;}//后序遍历//合并两个有序数组int gap = 1;//每组需要归并的个数while(gap<n){//层序遍历for(int i=0;i<n;i+=2*gap){int begin1 = i;int end1 = i+gap-1;int begin2 = i+gap;int end2 = i+2*gap-1;int j = i;if (begin2 >= n) {break;}if (end2 >= n) {end2 = n - 1;}while (begin1 <= end1 && begin2 <= end2) {if (a[begin1] < a[begin2]) {//begin1的数比begin2小，尾插begin1tmp[j++] = a[begin1];begin1++;}else {tmp[j++] = a[begin2];begin2++;}}//循环结束，说明有一方指针已经走完//将另一方未走完指针走完while (begin1 <= end1) {tmp[j++] = a[begin1];begin1++;}while (begin2 <= end2) {tmp[j++] = a[begin2];begin2++;}//此时的tmp数组为有序数组//拷贝回原数组memcpy(a+i, tmp+i, sizeof(int) * (end2-i+1));//易错点：(end2-begin1+1)是错的，因为begin1这个时候已经不再是子数组起点位置}gap *= 2;}}int main() {int a1[8] = { 10,6,7,1,3,9,4,2 };int a2[16] = { 16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 };int a3[12] = { 12,11,10,9,8,7,6,5,4,3,2,1 };MergeSort2(a1, 8);for (int i = 0; i < 8; i++) {printf("%d ", a1[i]);}printf("\n");MergeSort2(a2, 16);for (int i = 0; i < 16; i++) {printf("%d ", a2[i]);}MergeSort2(a3, 12);printf("\n");for (int i = 0; i < 12; i++) {printf("%d ", a3[i]);}}

🤔时间复杂度

O（N*logN)

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

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

相关文章

2024 年适用于 Linux 的 5 个微软 Word 替代品

2024 年适用于 Linux 的 5 个微软 Word 替代品

对于那些最近由于隐私问题或其他原因而转向 Linux 的用户来说&#xff0c;可能很难替换他们最喜欢的、不在 Linux 操作系统上运行的应用程序。 寻找流行程序的合适替代品可能会成为一项挑战&#xff0c;而且并不是每个人都准备好花费大量时间来尝试弄清楚什么可以与他们在 Win…
阅读更多...
读书笔记|《把自己变成稀缺资产》：我们都拥有100分的欲望，却只有1分的耐心。

读书笔记|《把自己变成稀缺资产》：我们都拥有100分的欲望，却只有1分的耐心。

哈喽&#xff0c;你好啊&#xff0c;我是雷工&#xff01; 最近在读一本书《把自己变成稀缺资产》&#xff0c;其中一章讲到耐心的重要性&#xff0c;很有共鸣。 当今社会&#xff0c;生活节奏越来越快&#xff0c;我们都在急于求成的追求结果&#xff0c;对过程越来越缺乏耐…
阅读更多...
2024050402-重学 Java 设计模式《实战责任链模式》

2024050402-重学 Java 设计模式《实战责任链模式》

重学 Java 设计模式&#xff1a;实战责任链模式「模拟618电商大促期间&#xff0c;项目上线流程多级负责人审批场景」 一、前言 场地和场景的重要性 射击&#x1f3f9;需要去靶场学习、滑雪&#x1f3c2;需要去雪场体验、开车&#x1f697;需要能上路实践&#xff0c;而编程…
阅读更多...
Scanpy（4）用与数据整合和批次处理

Scanpy（4）用与数据整合和批次处理

Scanpy包，用与数据整合和批次处理，包含批次效应的BBKNN算法和用于对比的ingest基础算法比较，及其原理简介。 1. 依赖： （1）数据集（全部需要挂VPN）： PBMC：pbmc3k_processed()（需要下载）；pbmc68k_reduced()（scanpy自带）Pancreas（需要下载）（2）Python包：Scanp…
阅读更多...
【Python】把xmind转换为指定格式txt文本

【Python】把xmind转换为指定格式txt文本

人工智能训练通常需要使用文本格式&#xff0c;xmind作为一种常规格式不好进行解析&#xff0c;那如何把xmind转换为txt格式呢&#xff1f; 软件信息 python python -v Python 3.9.13 (tags/v3.9.13:6de2ca5, May 17 2022, 16:36:42) [MSC v.1929 64 bit (AMD64)] on win32…
阅读更多...
Python 包安装及常用命令【python 入门】

Python 包安装及常用命令【python 入门】

背景&#xff1a; 近期看到一个项目&#xff0c;做微信只能机器人&#xff0c;服务是使用python搭建的&#xff0c;于是拷贝下来自己打算跑一跑&#xff0c;部署一下&#xff0c;可是自己又没有python的经验&#xff0c;于是各种查资料学习&#xff0c;跟着敲一敲&#xff0c;顺…
阅读更多...
Go 1.19.4 切片与子切片-Day 05

Go 1.19.4 切片与子切片-Day 05

1. 切片 1.1 介绍 切片在Go中是一个引用类型&#xff0c;它包含三个组成部分&#xff1a;指向底层数组的指针&#xff08;pointer&#xff09;、切片的长度&#xff08;length&#xff09;以及切片的容量&#xff08;capacity&#xff09;&#xff0c;这些信息共同构成了切片的…
阅读更多...
JavaWeb_SpringBootWeb案例

JavaWeb_SpringBootWeb案例

环境搭建&#xff1a; 开发规范 接口风格-Restful&#xff1a; 统一响应结果-Result&#xff1a; 开发流程&#xff1a; 第一步应该根据需求定义表结构和定义接口文档 注意&#xff1a; 本文代码从上往下一直添加功能&#xff0c;后面的模块下的代码包括前面的模块&#xff0c…
阅读更多...
Xmind Pro 2024 专业版激活码（附下载链接）

Xmind Pro 2024 专业版激活码（附下载链接）

说到思维导图&#xff0c;就不能不提 Xmind。这是一款优秀的思维导图工具&#xff0c;拥有着丰富的导图模板&#xff0c;漂亮的界面和配色&#xff0c;以及各种各样的创意工具。 新架构速度更快 采用全新 Snowdancer 引擎&#xff0c;一种堪称「黑科技」的先进图形渲染技术。…
阅读更多...
翘首以盼的抗锯齿

翘首以盼的抗锯齿

Antialiasing 实际的图形学中是怎么实现反走样的呢&#xff1f; 我们不希望实际产出的图形有锯齿效果&#xff0c;那怎么办呢&#xff1f; 从采样的理论开始谈起吧 Simpling theory 照片也是一种采样&#xff0c;把景象打散成像素放到屏幕上的过程&#xff1a; 还可以在不…
阅读更多...
21 - 即时食物配送 II（高频 SQL 50 题基础版)

21 - 即时食物配送 II（高频 SQL 50 题基础版)

21 - 即时食物配送 II -- sum(if(order_datecustomer_pref_delivery_date,1,0))/count(*)sum(order_datecustomer_pref_delivery_date)/count(*) -- count(*),表示数据的行数&#xff0c;如果有分组&#xff0c;为分组后数据的行数select round(100*sum(if(order_datecustomer_…
阅读更多...
原来Stable Diffusion是这样工作的

原来Stable Diffusion是这样工作的

stable diffusion是一种潜在扩散模型&#xff0c;可以从文本生成人工智能图像。为什么叫做潜在扩散模型呢&#xff1f;这是因为与在高维图像空间中操作不同&#xff0c;它首先将图像压缩到潜在空间中&#xff0c;然后再进行操作。 在这篇文章中&#xff0c;我们将深入了解它到…
阅读更多...
达摩院重大“遗产”！fluxonium量子比特初始化300纳秒且保真度超过99%

达摩院重大“遗产”！fluxonium量子比特初始化300纳秒且保真度超过99%

通用量子计算机开发的主要挑战之一是制备量子比特。十多年来&#xff0c;研究人员在构建量子计算机的过程中主要使用了transmon量子比特&#xff0c;这也是迄今为止商业上最成功的超导量子比特。 但与业界多数选择transmon量子比特不同&#xff0c;&#xff08;前&#xff09;…
阅读更多...
Python文本处理利器：jieba库全解析

Python文本处理利器：jieba库全解析

文章目录 Python文本处理利器&#xff1a;jieba库全解析第一部分&#xff1a;背景和功能介绍第二部分&#xff1a;库的概述第三部分&#xff1a;安装方法第四部分&#xff1a;常用库函数介绍1. 精确模式分词2. 全模式分词3. 搜索引擎模式分词4. 添加自定义词典5. 关键词提取 第…
阅读更多...
服务器遭遇UDP攻击时的应对与解决方案

服务器遭遇UDP攻击时的应对与解决方案

UDP攻击作为分布式拒绝服务(DDoS)攻击的一种常见形式&#xff0c;通过发送大量的UDP数据包淹没目标服务器&#xff0c;导致网络拥塞、服务中断。本文旨在提供一套实用的策略与技术手段&#xff0c;帮助您识别、缓解乃至防御UDP攻击&#xff0c;确保服务器稳定运行。我们将探讨监…
阅读更多...
最新PHP众筹网站源码 支持报名众筹+商品众筹+公益众筹等多种众筹模式 含完整代码包和部署教程

最新PHP众筹网站源码 支持报名众筹+商品众筹+公益众筹等多种众筹模式 含完整代码包和部署教程

在当今互联网飞速发展的时代&#xff0c;众筹模式逐渐成为了创新项目、商品销售和公益活动融资的重要渠道。分享一款最新版的PHP众筹网站源码&#xff0c;支持报名众筹、商品众筹和公益众筹等多种众筹模式。该源码包含了完整的代码包和详细的部署教程&#xff0c;让新手也可以轻…
阅读更多...
利用医学Twitter进行病理图像分析的视觉-语言基础模型| 文献速递-视觉通用模型与疾病诊断

利用医学Twitter进行病理图像分析的视觉-语言基础模型| 文献速递-视觉通用模型与疾病诊断

Title 题目 A visual–language foundation model for pathology image analysis using medical Twitter 利用医学Twitter进行病理图像分析的视觉-语言基础模型 01 文献速递介绍 缺乏公开可用的医学图像标注是计算研究和教育创新的一个重要障碍。同时&#xff0c;许多医生…
阅读更多...
自动化测试-Selenium(一)，简介

自动化测试-Selenium(一)，简介

自动化测试-Selenium 1. 什么是自动化测试 1.1 自动化测试介绍 自动化测试是一种通过自动化工具执行测试用例来验证软件功能和性能的过程。与手动测试不同&#xff0c;自动化测试使用脚本和软件来自动执行测试步骤&#xff0c;记录结果&#xff0c;并比较预期输出和实际输出…
阅读更多...
【Python报错】已解决ModuleNotFoundError: No module named ‘timm’

【Python报错】已解决ModuleNotFoundError: No module named ‘timm’

成功解决“ModuleNotFoundError: No module named ‘timm’”错误的全面指南 一、引言 在Python编程中&#xff0c;经常会遇到各种导入模块的错误&#xff0c;其中“ModuleNotFoundError: No module named ‘timm’”就是一个典型的例子。这个错误意味着你的Python环境中没有安…
阅读更多...
Navicate 导入导出数据库

Navicate 导入导出数据库

导出数据库 找地方存在来&#xff0c;别忘了放在那里。 新建一个数据库&#xff0c;记得要和导出数据库的 字符集与排序规则 相同 打开数据库后&#xff0c;我们选择它&#xff08;就是单击它&#xff09;然后右键打开菜单-运行sql文件 找到刚才存储的位置&#xff0c;开始 &a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023