常见的排序算法 | 直接插入排序 | 希尔排序 | 选择排序 | 堆排序 | 冒泡排序 | 快速排序 | 归并排序 |（详解，附动图，代码）

news/2024/4/24 7:09:33/文章来源:https://blog.csdn.net/xqk_gkb/article/details/129085017

 4fefdd0756be4e57887773f6d6daa386.gif

f584449103c24e30b53a0ccd3b77a6b5.gif

  思维导图：

78e6fc8053494490b52dfea21c9bf732.png

一.插入排序

1.直接插入排序（InsertSort）

①手机通讯录时时刻刻都是有序的，新增一个电话号码时，就是使用插入排序的方法将其插入原有的有序序列。

7debdc43bfed4da2be11c09fc777f061.png

②打扑克

57aba511cf52ff9449127945ccf639e5.jpeg

步骤：

  • ①如果一个序列只有一个数，那么该序列自然是有序的。插入排序首先将第一个数视为有序序列，然后把后面的元素视为要依次插入的序列。
  • ②我们通过外层循环控制要插入的数（下标表示），从下标为1处的元素开始插入，直到最后一个元素，然后用insertVal保存要插入的值。
  • ③内层循环负责交换，升序降序根据需求设计。
  • ④内层循环结束，继续进行外层循环，插入下一个元素，进行排序，直到整个序列有序。

动图演示：

3493efe457dd464f8fb207c70294c729.gif

6a9266555750484b97ef04d6be7db7c0.gif

//插入排序
void InsertSort(int* arr, int n)
{int i, j, insertVal;for (i = 1; i < n; i++) //控制要插入的数{insertVal = arr[i];//先保存要插入的值//内层控制比较,j 要大于等于 0，同时 arr[j]大于 insertval 时，arr[j]位置元素往后覆盖for (j=i-1; j >= 0 && arr[j] > insertVal; j--){arr[j + 1] = arr[j];}arr[j + 1] = insertVal;//将insertVal插入两个极端情况//1.前面的数字小于insertVal，不进入内层循环，直接原地不动//2.前面的数字都大于insertVal，x放在下标为0处}
}

效果：

d4e6c7ecf96d46f68381f365a2df68ec.png

结论：

  • 1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  • 2. 时间复杂度：O(N^2)
  • 3. 空间复杂度：O(1)，它是一种稳定的排序算法
  • 4. 稳定性：稳定

 2.希尔排序（Shellsort）

希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。

步骤：

  • 1.对待排序的序列进行预排，让序列接近有序。
  • 预排也是借助直接插入排序实现，具体实现方法，规定一个增量（gap），间隔为gap的元素为一组，然后分组排序，直到间隔gap的所有分组排序完成，增量(gap)减少，继续间隔为gap的元素进行分组排序 ，当增量减至1时，预排完成。
  • gap越大，大的数可以越快的到后面，小的数可以越快的到前面。
    gap越大，预排完越不接近有序。
    gap越小，越接近有序。
  • 2.gap=1，直接进行直接插入排序。

动图： 0afea2cf02414c4180309422312d0222.gif

c40d07046d9c4f578dcf8246ad033fbd.gif

//希尔排序
void ShellSort(int* arr, int n)
{int gap=n;int i ,insertVal;while (gap> 1){//每次对gap折半操作gap = gap / 2;//间隔为gap的所有组进行插入排序for (i = 0; i < n-gap; i++){//组员i+gap（下标）最大到n-1，再多就越界访问了，所以i<=n-1-gap，上面是开区间表示insertVal = arr[i+gap];for (i; i >= 0 && arr[i] > insertVal; i-=gap){arr[i+gap] = arr[i];}arr[i+gap] = insertVal;}
}
}

9cdc32c9b0b346759100c71841d8ef3c.png

希尔排序的特性总结：

  • 1. 希尔排序是对直接插入排序的优化。
  • 2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的 了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的 对比。
  • 3. 希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间复杂度： O(N^1.3— N^2）
  • 4. 稳定性：不稳定 

二.选择排序

3.选择排序（SelectSort）

步骤：

遍历一遍，从待排序列中选出一个最小值，然后放在序列的起始位置，再找次小的，直到整个序列排完。

动图演示：

80ef254d56994bf2a276e3631880d1f3.gif

但这种太慢了，实际上，我们可以一趟选出两个值，一个最大值一个最小值，然后将其放在序列开头和末尾，这样可以使选择排序的效率快一倍。

a47a7f8bf44a4feb9182d8390493da59.gif

void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}
//选择排序
void SelectSort(int* arr, int n)
{int begin = 0, end = n - 1;while (begin < end){int mini = begin, maxi = begin;//初始化，让最大值和最小值起初都是自己，作为一个基准for (int i = begin; i <= end; i++){if (arr[i] < arr[mini]){mini = i;//不断更新在此次遍历过程中遇到的最小值}if (arr[i] > arr[maxi]){maxi = i;//不断更新在此次遍历过程中遇到的最大值}}Swap(&arr[begin], &arr[mini]);//此次遍历最小的放到begin处//注意：最小值已经放到了begin处，但如果begin原先存的是此次遍历最大的数//那么你一交换，把最大的数给交换到了，mini处，所以我们要修正if (begin == maxi){// 如果begin跟maxi重叠，需要修正一下maxi的位置maxi = mini;}Swap(&arr[maxi], &arr[end]);//此次遍历最大的放到end处begin++;end--;}
}

效果： 

3d081262481844e09475ee19b8c9404c.png

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

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

4.堆排序（HeapSort）

堆排序即利用堆的思想来进行排序

堆的性质：

• 堆中某个节点的值总是不大于或不小于其父节点的值

• 堆总是一棵完全二叉树

步骤：

  • 升序：建大堆，若父结点的值恒大于等于子结点的值，则该堆称为最大堆（max heap）
  • 降序：建小堆，若父结点的值恒小于等于子结点的值，则该堆称为最小堆（min heap）；

①建堆: 

堆的逻辑结构是一个完全二叉树，存储结构是数组，所以数组也可以看成一个堆，但还不满足堆的性质，而我们要做的就是调整数组，使之建堆成最大堆或最小堆

调整方法使用向下排序算法。

向下调整算法的核心思想：选出左右孩子中小的哪一个，跟父亲交换,如果要建大堆则相反

向下调整算法的前提：建小堆，左右子树都必须是小堆，才能够进行调整，大堆相反。

但数组满足不了这个前提，我们就换一种思想，从倒数第一个非叶子结点（最后一个结点的父亲）开始调整。

②排序

假设我们建的是大堆，父结点的值恒大于等于子结点的值，然后按照堆删的思想将堆顶和堆底的数据交换，但不同的是这里不删除最后一个元素。这样最大元素就在最后一个位置，然后从堆顶向下调整到倒数第二个元素，这样次大的元素就在堆顶，重复上述步骤直到只剩堆顶时停止。

数组确定父子关系：

lchild(左孩子)=parent（父亲）*2+1
rchild(右孩子)=parent（父亲）*2+2

85084a8d49c943cba561daa733c410ec.png

动图演示： 

a5e5324cbce6413d8b07367fec705b26.gif

abe4f4a736b54cb69ac98ed1a97392ac.gif

//建堆
void AdjustDown(int* arr, int n, int root)//向下调整
{int parent = root;int child = parent * 2 + 1;while (child < n){if (child + 1 < n && arr[child + 1] > arr[child]){child++;}if (arr[child] > arr[parent]){Swap(&arr[child], &arr[parent]);parent = child;child = parent * 2 + 1;}else{break;}}
}
//堆排序
void HeapSort(int* arr, int n)
{//建堆for (int i = (n - 1 - 1) / 2; i >= 0; i--){AdjustDown(arr, n, i);}//交换for (int i = n - 1; i > 0; i--){Swap(&arr[i], &arr[0]);AdjustDown(arr, i, 0);}
}

3d081262481844e09475ee19b8c9404c.png

堆排序的特性总结：

  • 1. 堆排序使用堆来选数，效率就高了很多。
  • 2. 时间复杂度：gif.latex?O%28N*%5Clog_%7B2%7DN%29
  • 3. 空间复杂度：O(1)
  • 4. 稳定性：不稳定 

三.交换排序

5.冒泡排序（BubbleSort）

两两相邻元素进行比较，并且可能需要交换，一趟下来该趟的最大（小）值在最右边。

动图演示：

4ef5aca510084394b58bce03cce9088b.gif

5a8d07f5eeb14fa59aebc2e723eefdc2.gif

void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}
//冒泡排序
void BubbleSort(int* arr, int n)
{for (int i = 0; i < n; i++)//控制趟数{int exchange = 0;//记录交换次数for (int j = 0; j < n - 1 - i; j++){//第一趟比较n-1次，然后每走完i趟，就有i个右边的位被占，所以比较次数减iif (arr[j] > arr[j + 1]){Swap(&arr[j], &arr[j + 1]);exchange = 1;}}if (exchange == 0){//交换次数为0，排序直接结束break;}}
}

488d2248e8274dd5834899e7980a4129.png

 冒泡排序的特性总结：

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

6.快速排序（QuickSort）

【递归实现】：

快速排序的核心是分治思想：

假设我们的目标依然是按从小到大的顺序排列，我们找到数组中的一个分割值，把比分割值小的数都放在数组的左边，把比分割值大的数都放在数组的右边，这样分割值的位置就被确定。借助分割值的位置把数组一分为二，前一半数组和后一半数组继续找分割值的位置， 不断地进行递归，最终分割得只剩一个时，整个序列自然就是有序的。

重点在于怎么确定分割值的位置，下面有挖坑法，左右指针法，和前后指针法三种方法。

6.1挖坑法

挖坑法确定分割值的位置

步骤：

  • ①定义一个分割值key，一般是将待排序序列的最左边或最右边的数据取出赋给key，（下面以最左面为例）那么最最左边数据就可以被覆盖，就是所谓的坑。
  • ②left代表待排序序列最左端，right代表待排序序列最右端                                        
  • ③首先坑在最左边，所以我们让right先走，去找比key小的值，放到最左边的坑，然后此时的right变成了坑，所以left在走，找比key大的值，放到此时的right，然后right再走，找比key小的值，放到此时的left，如此进行下去，直到left和right最终相遇，将key放到相遇点这个坑，这时相遇点就是分割值的位置。
  • ④借助分割值的位置把数组一分为二，前一半数组和后一半数组继续采用这种思想， 不断地进行递归，最终分割得只剩一个时，整个序列自然就是有序的。

动图演示：

f085bf8ac37e4adab00b3f17460c25b5.gif

71cac8a618164776b41004292f4af3c1.gif

//挖坑法确定分割值的位置
int PartSort1(int* arr, int left, int right)
{int key = arr[left];//取出分割值int hole = left;//保存坑的位置while (left < right){// 右边找小，放到左边while (left < right && arr[right] >= key){right--;}// 不满足上边的循环，就说明右边的right有小的要放到左边的left坑里	arr[hole] = arr[right];hole = right;//更新坑的位置// 左边找大while (left < right && arr[left] <= key){left++;}// 不满足上边的循环，就说明左边begin有大的放到右边end的坑里arr[hole] = arr[left];hole = left;}arr[hole] = key;return hole;//本次排序完成，返回分割值key的下标
}
//快速排序
void QuickSort(int* arr, int left, int right)
{if (left >= right){//递归停止的条件return;}int keyi = PartSort1(arr, left, right);//每一趟排序完成都会返回一个分割值key的下标//借助分割值的位置将序列分为左子区间[left,keyi-1]和右子区间[keyi+1,right]//再用分治递归使左子区间和右子区间有序QuickSort(arr, left, keyi - 1);QuickSort(arr, keyi + 1, right);
}

效果：

2291b9011f574fb6bb0f8566f1a19c54.png

6.2左右指针法

左右指针法确定分割值的位置

步骤：

  • ①选定一个分割值key，一般是待排序序列的最左边或最右边。
  • ②left代表待排序序列最左端，right代表待排序序列最右端       
  • ③假设key在最左边，那么right先走遇到比key小的值就停下，不发生交换，然后left开始走，直到left遇到一个大于key的数时，将left和right的内容交换，right再次开始走，如此进行下去，直到left和right最终相遇，此时将相遇点的内容与key的内容交换即可，这时相遇点就是分割值的位置。
  • ④借助分割值的位置把数组一分为二，前一半数组和后一半数组继续采用这种思想， 不断地进行递归，最终分割得只剩一个时，整个序列自然就是有序的。

动图演示：

f68a2fcf79d44eca8365f98535961936.gif

1220a19652a64f60b7734a899544c15b.gif

//左右指针法确定key的位置
int PartSort2(int* arr, int left, int right)
{int key =left;//选定分割值while (left < right){// 找小while (left < right && arr[right] >=arr[key]){right--;}// 找大while (left < right && arr[left] <=arr[key]){left++;}Swap(&arr[left], &arr[right]);}                        Swap(&arr[left], &arr[key]);return left;//本次排序完成，返回分割值key的下标
}
//快速排序
void QuickSort(int* arr, int left, int right)
{if (left >= right){//递归停止的条件return;}int keyi = PartSort2(arr, left, right);//每一趟排序完成都会返回一个分割值key的下标//借助分割值的位置将序列分为左子区间[left,keyi-1]和右子区间[keyi+1,right]//再用分治递归使左子区间和右子区间有序QuickSort(arr, left, keyi- 1);QuickSort(arr, keyi+ 1, right);
}

6.3前后指针法

前后指针版本确定分割值的位置

步骤：

  • ①规定一个分割值key，一般是最左边或是最右边的。
  • ②起始时，prev指针指向序列开头，cur指针指向prev+1。
  • ③cur从左至右遍历，若cur指向的内容小于key，则prev先向后移动一位，然后交换prev和cur指针指向的内容，然后cur指针++；若cur指向的内容大于key，则cur指针直接++。如此进行下去，直到cur到达end位置，此时将key和prev++指针指向的内容交换即可。
  • 4.这样做本质上就是cur指针遍历一遍待排序序列，把所有小于key的数据都放到下标[1，prev]这个区间，然后把key和prev的内容交换。
  • 5.key将待排序序列该分成了两半，左边比他小，右边比他大，然后再让左右序列进行上述操作，直至左右序列分割得只剩一个元素时，整个序列自然就是有序的。

ee80ef4416984f5aabc18093651e13d8.gif

//前后指针版本确定分割值的位置
int PartSort3(int* arr, int left, int right)
{int key =left;//选定分割值int cur=left+1;int prev=left;while(cur<=right){while(arr[cur]<arr[key]&&++prev!=cur){//只要a[cur]<a[key]语句为真，prev必须要进行++，但不一定要发生交换，因为prev++=cur，自己和自己交换没意义。Swap(&arr[cur],&arr[prev]);}        cur++; }       Swap(&arr[key], &arr[prev]);return prev;//本次排序完成，返回分割值key的下标
}
//快速排序
void QuickSort(int* arr, int left, int right)
{if (left >= right){//递归停止的条件return;}int keyi = PartSort3(arr, left, right);//每一趟排序完成都会返回一个分割值key的下标//借助分割值的位置将序列分为左子区间[left,keyi-1]和右子区间[keyi+1,right]//再用分治递归使左子区间和右子区间有序QuickSort(arr, left, keyi- 1);QuickSort(arr, keyi+ 1, right);
}

6.4快速排序的优化

1.我们在分割值的选择上可以进行优化，假如我要实现升序，原待排序序列接近降序，这就会造成效率太低，递归次数过多，导致栈溢出。所以我们可以选出一个中间值和最左（右）边交换。

方法：三数取中

//三数取中
int MidIndex(int* a, int left, int right)
{int mid = (left + right) / 2;//防止mid越界//int mid = left+(right - left) / 2;if (a[left] < a[right]){if (a[mid] < a[left]){return left;}else if (a[mid] > a[right]){return right;}else{return mid;}}else{if (a[mid] > a[left]){return left;}else if (a[mid] < a[right]){return right;}else{return mid;}}
}

2.减少递归次数，方法：小区间优化

bf7ffaaf19a9433da0a796d591082598.png

 以左右指针法举例

// 三数取中
int GetMidIndex(int* a, int left, int right)
{int mid = (left + right)/2;if (a[left] < a[mid]){if (a[mid] < a[right]){return mid;}else if (a[left] > a[right]){return left;}else{return right;}}else // a[left] > a[mid]{if (a[mid] > a[right]){return mid;}else if (a[left] < a[right]){return left;}else{return right;}}
}
//左右指针法确定key的位置
int PartSort2(int* arr, int left, int right)
{int mid = GetMidIndex(arr, left, right);//将分割值调整至最左边Swap(&arr[mid], &arr[left]);int key =left;//选定分割值while (left < right){// 找小while (left < right && arr[right] >=arr[key]){right--;}// 找大while (left < right && arr[left] <=arr[key]){left++;}Swap(&arr[left], &arr[right]);}                        Swap(&arr[left], &arr[key]);return left;//本次排序完成，返回分割值key的下标
}
//快速排序
void QuickSort(int* arr, int left, int right)
{if (left >= right){return;}//小区间优化，，减少递归次数if (right - left + 1 < 10){InsertSort(arr + left, right -left + 1);}else{int keyi = PartSort2(arr, left, right);//每一趟排序完成都会返回一个分割值key的下标//借助分割值的位置将序列分为左子区间[left,keyi-1]和右子区间[keyi+1,right]//再用分治递归使左子区间和右子区间有序QuickSort(arr, left, keyi - 1);QuickSort(arr, keyi + 1, right);}
}

【非递归版本】

我们可以借助栈的思想，递归是一直递到限制条件，然后开始回归，最后一次调用先完，然后倒数第二次……，和栈的先进后出思想很像所以我们可以借助栈来实现。

6.5栈实现

typedef int  STDataType;
typedef struct Stack
{STDataType* a;int top;int capacity;
}ST;
void StackInit(ST* ps)
{assert(ps);ps->a = (STDataType*)malloc(sizeof(STDataType)* 4);if (ps->a == NULL){printf("malloc fail\n");exit(-1);}ps->capacity = 4;ps->top = 0;
}void StackDestory(ST* ps)
{assert(ps);free(ps->a);ps->a = NULL;ps->top = ps->capacity = 0;
}
// 入栈
void StackPush(ST* ps, STDataType x)
{assert(ps);// 满了-》增容if (ps->top == ps->capacity){STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));if (tmp == NULL){printf("realloc fail\n");exit(-1);}else{ps->a = tmp;ps->capacity *= 2;}}ps->a[ps->top] = x;ps->top++;
}// 出栈
void StackPop(ST* ps)
{assert(ps);// 栈空了，调用Pop，直接中止程序报错assert(ps->top > 0);//ps->a[ps->top - 1] = 0;ps->top--;
}STDataType StackTop(ST* ps)
{assert(ps);// 栈空了，调用Top，直接中止程序报错assert(ps->top > 0);return ps->a[ps->top - 1];
}int StackSize(ST* ps)
{assert(ps);return ps->top;
}bool StackEmpty(ST* ps)
{assert(ps);return ps->top == 0;
}
//前后指针版本确定分割值的位置
int PartSort1(int* arr, int left, int right)
{int key = arr[left];//取出分割值int hole = left;//保存坑的位置while (left < right){// 右边找小，放到左边while (left < right && arr[right] >= key){right--;}// 不满足上边的循环，就说明右边的right有小的要放到左边的left坑里	arr[hole] = arr[right];hole = right;//更新坑的位置// 左边找大while (left < right && arr[left] <= key){left++;}// 不满足上边的循环，就说明左边begin有大的放到右边end的坑里arr[hole] = arr[left];hole = left;}arr[hole] = key;return hole;//本次排序完成，返回分割值key的下标
}
// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
{//创建栈Stack st;StackInit(&st);//原始数组区间入栈StackPush(&st, right);StackPush(&st, left);//将栈中区间排序while (!StackEmpty(&st)){//注意：如果right先入栈，栈顶为leftleft = StackTop(&st);StackPop(&st);right = StackTop(&st);StackPop(&st);//得到分割值的下标int keyi = PartSort1(a, left, right);// 以分割值下标分割点，形成左右两部分//分别入栈if (right > keyi + 1){StackPush(&st, right);StackPush(&st, keyi + 1);}if (left < keyi - 1){StackPush(&st, keyi - 1);StackPush(&st, left);}}StackDestory(&st);
}

 快速排序的特性总结：

  • 1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  • 2. 时间复杂度：gif.latex?O%28N*%5Clog_%7B2%7DN%29
  • 3. 空间复杂度：gif.latex?O%28N*%5Clog_%7B2%7DN%29
  • 4. 稳定性：不稳定

四.归并排序

7.归并排序（MergeSort）

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

步骤：

使用归并的前提是所有子序列都有序，所以我们对待排序序列进行分割，一分二，二分四…………直至子序列只有一个数字，一个数字总该认为他有序吧。 将已有序的子序列合并，得到完全有序的序列；注意：（两个子序列合并成一个子序列，序列要进行排序，确保该子序列有序，以便后续合并），若将两个有序表合并成一个有序表，称为二路归并。 

bd369e3f46474d39a3c5624f4acf9f34.png

动图演示：

60df75589d7c4d798303aeb306116e35.gif

9052fbdf0c13435b83af37b58de9c82a.gif

void _MergeSort(int* arr, int left, int right, int* tmp)
{if (left >= right){//子序列分割只剩一个元素，停止，跳到上一级归并return;}int mid = (left + right) >> 1;//分割，一分二……_MergeSort(arr, left, mid, tmp);//划分左区间[left, mid]_MergeSort(arr, mid+1, right, tmp);//划分右区间[mid+1, right]//分割完成开始归并int begin1 = left, end1 = mid;//左区间int begin2 = mid + 1, end2 = right;//右区间int index = left;while (begin1 <= end1 && begin2 <= end2){//注意结束条件为一个序列为空时就停止//合并的序列可能不一样长if (arr[begin1] < arr[begin2]){//为了实现合并后的子序列有序，我们要对要合并的两个序列的元素进行一一比较，比较结果放到        //临时数组，然后再把临时数组赋给原序列。tmp[index++] = arr[begin1++];//一定是后置++，复制完确保指向下一个元素}else{tmp[index++] = arr[begin2++];}}//两序列不可能同时为空，可能有瘸腿的情况，将剩余元素合并while (begin1 <= end1){tmp[index++] = arr[begin1++];}while (begin2 <= end2){tmp[index++] = arr[begin2++];}//将合并后的序列拷贝到原数组中//在这里拷贝的原因是保证返回到上一层递归后两个子序列中的元素是有序的for (int i = left; i <= right; ++i){arr[i] = tmp[i];}
}
//归并排序
void MergeSort(int* arr, int n)
{int* tmp = (int*)malloc(sizeof(int)*n);//临时数组，左右区间归并时排序要借助临时数组//防止覆盖待排序序列，造成错误if (tmp == NULL){perror("malloc");exit(-1);}	_MergeSort(arr, 0, n - 1, tmp);//分割归并free(tmp);tmp=NULL;
}

归并排序的特性总结：

  • 1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问 题。
  • 2. 时间复杂度：gif.latex?O%28N*%5Clog_%7B2%7DN%29
  • 3. 空间复杂度：O(N)
  • 4. 稳定性：稳定

排序算法复杂度及稳定性分析：

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAc2tlZXQgIGZvbGxvd2Vy,size_20,color_FFFFFF,t_70,g_se,x_16

 博主水平有限，如有错误还请多多包涵。

16c406176fa843fb9cf241a2bae977fd.gif

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

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

相关文章

报表开发难上手？这里有一份 Fastreport 最新中文用户指南，请查收

报表开发难上手？这里有一份 Fastreport 最新中文用户指南，请查收

Fast Reports,Inc.成立于1998年&#xff0c;多年来一直致力于开发快速报表软件&#xff0c;包括应用程序、库和插件。FastReport的报表生成器&#xff08;VCL平台和.NET平台&#xff09;、跨平台的多语言脚本引擎FastScript、桌面OLAP FastCube&#xff0c;如今都受到世界各地开…
阅读更多...
工赋开发者社区 | 工业数字孪生:西门子工业网络与设备虚拟调试案例（TIA+MCD+SINETPLAN)

工赋开发者社区 | 工业数字孪生:西门子工业网络与设备虚拟调试案例（TIA+MCD+SINETPLAN)

PART1案例背景及基本情况新生产系统的设计和实施通常是耗时且高成本的过程&#xff0c;完成设计、采购、安装后&#xff0c;在移交生产运行之前还需要一个阶段&#xff0c;即调试阶段。如果在开发过程中的任何地方出现了错误而没有被发现&#xff0c;那么每个开发阶段的错误成本…
阅读更多...
建议收藏！数据可视化大屏设计必备步骤

建议收藏！数据可视化大屏设计必备步骤

相信对于从事大数据相关的人员来说&#xff0c;数据的可视化大屏是最能展现自己工作价值的一个途径。可视化大屏就是数据分析的最后成果的展示&#xff0c;而如果能设计出更直观、更酷炫、更具有科技感的大屏&#xff0c;更能获得客户的青睐。 那么客户喜欢的究竟是怎样的可视化…
阅读更多...
嵌入式开发：在嵌入式应用程序中混合C和C++

嵌入式开发：在嵌入式应用程序中混合C和C++

许多嵌入式应用程序仍使用c语言编写&#xff0c;但越来越多的嵌入式开发人员现在使用C语言编写程序。某些应用程序甚至共享这两种语言。这有意义吗?C是嵌入式应用中最常用的编程语言。多年来&#xff0c;人们一直期待着向C过渡&#xff0c;但过渡速度相当缓慢。但是&#xff0…
阅读更多...
Appium自动化测试 Inspector定位Webview/H5页面元素

Appium自动化测试 Inspector定位Webview/H5页面元素

目录操作步骤Python操作该混合App代码Appium在操作混合App或Android App的H5页面时, 常常需要定位H5页面中的元素, 传统方式是 FQ 使用Chrome://inspect来定位元素, 环境准备相当繁琐, 不仅需要想办法FQ, 而且还需要Android设备安装Google框架以及手机版Chrome浏览器以及相应的…
阅读更多...
问题记录-网卡丢失导致Temporary failure in name resolution

问题记录-网卡丢失导致Temporary failure in name resolution

没网了&#xff0c;ifconfig查看一下 发现是网卡丢失 使用如下命令&#xff1a; sudo ifconfig eth0 up sudo dhclient解决
阅读更多...
postgresql 数据库 主从切换 测试

postgresql 数据库 主从切换 测试

postgresql 数据库 主从切换 测试 文章目录postgresql 数据库 主从切换 测试前言环境&#xff1a;主从切换1. 查看数据库状态&#xff1a;2. 备库切换主库3. 旧主库切换成备库&#xff1b;4 查看状态后记前言 因数据库等保需要&#xff0c;需要对老系统的数据库进行主从切换来…
阅读更多...
考出PMP证书到底有没有用?

考出PMP证书到底有没有用?

我们将从三方面分享&#xff1a; 1. PMP 证书在国内的含金量怎么样&#xff1f; 2. HR 如何看待 PMP 证书&#xff1f; 3. 拿到 PMP 证书后&#xff0c;有哪些变化&#xff1f; 一&#xff0c;PMP证书的含金量 说到 PMP 证书的含金量&#xff0c;相信这个问题是所有学员都…
阅读更多...
JS语法让人困惑的点 “==与===”

JS语法让人困惑的点 “==与===”

在JS中有很多神奇的语法&#xff0c;非常让人困惑&#xff0c;我们就先一一道来&#xff0c;相信你在开发中或多或少都踩过这些坑&#xff0c;或者让人无法理解。 今天我们就来说下【】和【】 这题对于很多没有系统学过前端开发的技术人员来说&#xff0c;算个重点&#xff0c…
阅读更多...
Spring+MVC+MYbatis注解开发

Spring+MVC+MYbatis注解开发

Spring常见注解 注解一&#xff1a;Configuration 用在类上面&#xff0c;加上这个注解的类可以成为一个spring的xml配置文件&#xff0c;使用的是java代码的配置 注解二&#xff1a;ComponentScan 用在类上&#xff0c;加上注解可以指定扫描路径 注解三&#xff1a;创建对…
阅读更多...
面试 | 递归乘法【细节决定成败】

面试 | 递归乘法【细节决定成败】

不用[ * ]如何使两数相乘❓一、题目明细二、思路罗列 & 代码解析1、野蛮A * B【不符合题意】2、sizeof【可借鉴】解析3、简易递归【推荐】① 解析&#xff08;递归展开图&#xff09;② 时间复杂度分析4、移位<<运算【有挑战性&#x1f4aa;】① 思路顺理② 算法图解…
阅读更多...
啥是原神？女友说想要全角色语音+表情包，顺手用python把高清图也整下来了

啥是原神？女友说想要全角色语音+表情包，顺手用python把高清图也整下来了

原神全角色中日语音表情包高清图人生苦短 我用python表情包部分&#xff1a;1. 素材来自&#xff1a;2. 准备模块3. 调用浏览器驱动4. 页面滚动5. 保存数据5. 效果全角色语音高清彩图部分1.准备工具2. 准备模块3. 请求链接4. 本次目标5. 分析数据来源6. 开始代码7. 执行结果8. …
阅读更多...
Revit操作 | 门和窗的载入与放置。

Revit操作 | 门和窗的载入与放置。

想要系统性掌握BIM技能&#xff0c;不能只停留在理论知识上&#xff0c;实操也是关键一步。 拒绝纸上谈兵&#xff0c;提升操作技巧&#xff0c;从点滴开始积累。今天我们来学习Revit实操小技巧之门和窗的载入与放置。 门和窗的载入与放置 门和窗是建筑中最常用的构件。在 Re…
阅读更多...
单通道说话人语音分离——Conv-TasNet(Convolutional Time-domain audio separation Network)

单通道说话人语音分离——Conv-TasNet(Convolutional Time-domain audio separation Network)

单通道说话人语音分离——Conv-TasNet模型(Convolutional Time-domain audio separation Network) 参考文献&#xff1a;《Conv-TasNet: Surpassing Ideal Time-FrequencyMagnitude Masking for Speech Separation》 1.背景 在真实的声学环境中&#xff0c;鲁棒的语音处理通常…
阅读更多...
Unity（二）--通过简单例子了解UGUI几个常用对象操作(Text，Image，Button)

Unity（二）--通过简单例子了解UGUI几个常用对象操作(Text，Image，Button)

目录 文本框等UI对象的添加Canvas 画布给Canvas添加脚本，绑定要操作的对象文本框Text的使用图像Image的使用更换图片Type:显示图片相关按钮Button的使用过渡导航事件绑定文本框等UI对象的添加 Canvas 画布 当创建一个UI元素的时候，如果没有Canvas 画布，就会自动创建一个画布…
阅读更多...
PDMS二次开发（一）——PML类型程序类型与概念

PDMS二次开发（一）——PML类型程序类型与概念

目录前言一、PML类型与概念基础知识变量函数小例子注释PML表达式条件判断语句循环skip和break窗口程序在PDMS菜单栏中添加程序窗口自动定位PML常见控件前言 PDMS二次开发需要.net 有自带的PML语言和C# .net一般通常泛指的是C#语言 模型数据借助.NET的接口可以转换成数据库中的…
阅读更多...
MSP430F2132IRHBR功能框图TPS259824LNRGER电路保护和电源管理解决方案芯片

MSP430F2132IRHBR功能框图TPS259824LNRGER电路保护和电源管理解决方案芯片

概述&#xff1a;MSP430F21x2 16位超低功耗微控制器 (MCU) 是MSP430系列微控制器的一部分。这些MCU采用一种架构&#xff0c;加上5种低功耗模式&#xff0c;能在便携式测量应用中延长电池的使用寿命。这些器件具有一个强大的16位 RISC CPU、16位寄存器和用于获得最大编码效率的…
阅读更多...
OpenStack手动分布式部署Glance【Queens版】

OpenStack手动分布式部署Glance【Queens版】

目录 Glance简介 1、登录数据库配置&#xff08;在controller执行&#xff09; 1.1登录数据库 1.2数据库里创建glance 1.3授权对glance数据库的正确访问 1.4退出数据库 1.5创建glance用户密码为000000 1.6增加admin角色 1.7创建glance服务 1.8创建镜像服务API端点 2、安装gla…
阅读更多...
FinClip 的 2022 与 2023

FinClip 的 2022 与 2023

相比往年&#xff0c;今年复盘去年与展望新年的文章来的稍慢一点。不过也希望能够借这篇文章&#xff0c;和关注 FinClip 的用户朋友们一起聊聊&#xff0c;我们在去年和今年的想法与计划。 2022 在过去的一年中&#xff0c;我们的身边发生了很多事情&#xff0c;这些事情在不…
阅读更多...
CANoe-TestModule-vTESTstudio-Python -- 爱恨情仇

CANoe-TestModule-vTESTstudio-Python -- 爱恨情仇

前面有聊过什么才是真正的自动化平台&#xff1b;其实说起来也是每个测试人的工作之路&#xff0c;从入门的测试执行、测试用例设计、自动化脚本开发、自动化架构开发、自动化平台开发&#xff0c;实际上我们大多数测试人都在纠结第一步的测试执行和第三步的自动化脚本开发&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023

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