---

🚀一、选择排序

算法精炼每趟从待排序的记录中选出关键字最小的记录，顺序放在已排序的记录序列末尾，直到全部排序结束为止。

简单排序处理流程

1. 从待排序序列中，找到关键字最小的元素；
2. 如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；
3. 从余下的 N - 1 个元素中，找出关键字最小的元素，重复1、2步，直到排序结束。

或者：

1. 从待排序序列中，找到关键字最大的元素；
2. 如果最大元素不是待排序序列的最后一个元素，将其和最后一个元素互换；
3. 从余下的 N - 1 个元素中，找出关键字最大的元素，重复1、2步，直到排序结束。

时间复杂度：

• 简单选择排序的比较次数与序列的初始排序无关。 假设待排序的序列有 N 个元素，第一个元素和后面每个元素比较（n-1次），将最小的排在前面，再将第二个元素和后面每个元素比较（n-2次），则可以近似地表示为 (n-1) + (n-2) + … + 1。这是一个等差数列的求和，可以使用等差数列求和公式进行计算。比较次数总是N (N - 1) / 2。
• 所以，综合以上，简单排序的时间复杂度为 O(N^2)。

C语言代码实现：

 #include <stdio.h>
//最小值往前放
void SelectSort(int arr[], int len)
{if (len < 1 || arr == nullptr) return;for (int i = 0; i < len; i++){int minindex = i;//用来保存最小值的索引for (int j = i + 1; j < len; j++){if (arr[j] < arr[index]){index = j;}}int temp = arr[i];arr[i] = arr[index];arr[index] = temp;}
}
//最大值往后放
void SelectSort1(int arr[], int len)
{if (len < 1 || arr == nullptr) return;for (int i = len-1; i > 0; --i){int index = i;//用来保存最大值的索引for (int j = 0; j < i; j++){if (arr[j] > arr[index]){index = j;}}int temp = arr[index];arr[index] = arr[i];arr[i] = temp;}}
}void PrintAddr(int arr[], int len)
{for (int i = 0; i < len; i++)printf("%d ", arr[i]);printf("\n");
}
int main()
{int arr[] = { 9,1,2,5,7,4,8,6,3,5 };int len = sizeof(arr) / sizeof(arr[0]);SelectSort(arr, len);PrintAddr(arr, len);
}

🚀二、冒泡排序

算法精炼依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。

处理流程

1. 第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。
2. 比较第2和第3个数，将小数 放在前面，大数放在后面。…
3. 如此继续，直到比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成
4. 在上面一趟比较完成后，最后一个数一定是数组中最大的一个数，所以在比较第二趟的时候，最后一个数是不参加比较的。
5. 在第二趟比较完成后，倒数第二个数也一定是数组中倒数第二大数，所以在第三趟的比较中，最后两个数是不参与比较的。
6. 依次类推，每一趟比较次数减少依次

时间复杂度：

• N个数字要排序完成，总共进行N-1趟排序
• 每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数
• 冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。
• 如果我们的数据正序，总共只需要走一趟，这一趟比较N-1次，时间复杂度为O（N）
• 最坏情况我们的数据是反序的，则需要进行n-1趟排序。每趟排序要进行n-i次比较，总共进行n(n-1)/2次比较。时间复杂度为O(N^2)

C语言代码实现：

#include <stdio.h>void BubbleSort(int arr[],int len)
{if (len < 1 || arr==nullptr) return;for(int i=0;i<len;i++)for (int j=0; j < len-i-1; j++){if (arr[j]> arr[j + 1]){int temp = arr[j + 1];arr[j + 1] = arr[j];arr[j] = temp;}}
}void PrintAddr(int arr[], int len)
{for (int i = 0; i < len; i++)printf("%d ", arr[i]);printf("\n");
}int main()
{int arr[] = { 10,1,35,61,89,36,55};int len = sizeof(arr) / sizeof(arr[0]);BubbleSort(arr, len);PrintAddr(arr, len);
}

🚀三、插入排序

**算法精炼:**通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用 in-place 排序（即只需用到 O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

具体描述：

1. 从第一个元素开始，该元素可以认为已经被排序；
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
3. 将该元素从后往前与每一个已排序元素比较，找到恰好的位置插入，大于前一个，小于后一个
4. 将新元素插入到该位置；重复以上步骤 。

例子：

C语言代码实现：

#include <stdio.h>void InsertSort(int arr[], int len)
{for (int i = 1; i < len; i++){int curVaule = arr[i]; //从第二个元素开始int preIndex = i - 1;  //第一个元素下标while (preIndex >= 0 && arr[preIndex] > curVaule) //第一个数比新元素大{arr[preIndex + 1] = arr[preIndex];  //大的往后移preIndex--;  //继续判断前一个数}arr[preIndex + 1] = curVaule;  //直到找到小于或者等于新元素的数，while循环里面减去了1判断前一个，所以要加上}
}void PrintAddr(int arr[], int len)
{for (int i = 0; i < len; i++)printf("%d ", arr[i]);printf("\n");
}
int main()
{int arr[] = { 171,161,163,165,167,169 };int len = sizeof(arr) / sizeof(arr[0]);InsertSort(arr, len);PrintAddr(arr, len);
}

🚀四、希尔排序

插入排序虽好,但是某些特殊情况也有很多缺点,比如像下面这种情况

169 前的元素基本不用插入操作就已经有序, 元素 1 和 2 的排序几乎要移动数组前面的所有元素!!! 于是,有个老帅哥就提出了优化此问题的希尔排序!

算法精炼：是希尔（Donald Shell）于 1959 年提出的一种排序算法。也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。它与插入排序的不同之处在于，它会优先比较距离较远的元素 。

基本步骤：

1. 选择增量 ： gap=length/2，缩小增量： gap = gap/2
2. 增量序列：用序列表示增量选择， {n/2, (n/2)/2, …, 1}
3. 先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
   • 选择一个增量序列 t1，t2，…，tk，其中 ti>tj，tk=1；
   • 按增量序列个数 k，对序列进行 k 趟排序；
   • 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序;
   • 仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

C语言代码实现

#include<stdio.h>
void ShellSort(int arr[], int len)
{for (int gap = len / 2; gap > 0; gap /= 2){for (int i = gap; i<len; i++) //每个组执行插入排序{int curValue = arr[i]; //arr[i]就是第一组的第二个数据int preIndex = i - gap; //自然这个就是第一组的第一个元素while (preIndex >= 0 && arr[preIndex] > curValue){arr[preIndex + gap] = arr[preIndex];preIndex -= gap;}arr[preIndex + gap] = curValue;}}
}
void PrintAddr(int arr[], int len)
{for (int i = 0; i < len; i++)printf("%d ", arr[i]);printf("\n");
}
int main()
{int arr[] = { 8,9,1,7,2,3,5,4,6,0 };int len = sizeof(arr) / sizeof(arr[0]);ShellSort(arr, len);PrintAddr(arr, len);
}

🚀五、堆排序

**算法精炼：**指利用堆这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素

基本步骤：

1. 第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置
2. 然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾
3. 以此类推，直到全部待排序的数据元素的个数为零

C语言代码实现

void heapSort(Heap &heap){if (heap.size<1) return ;while(heap.size>0){int tmp = heap.arr[0];heap.arr[0] = heap.arr[heap.size-1];heap.arr[heap.size-1] = tmp;heap.size--;adjustDown(heap, 0);// 向下执行堆调整}
}

其中要用到堆的向下调整算法，因为当我们将数组进行一次选择排序后，就不满足最大堆了。所以找到堆最大元素比较麻烦，但调整到最大堆后，就很方便找到为heap.arr[0]

堆相关的知识：【数据结构篇C++实现】- 树

堆的向下调整算法：

/*向下调整将当前的节点和子节点调整成最大堆*/
void adjustDown(Heap &heap, int index) { int cur=heap.arr[index];//当前待调整的节点int parent,child;
/*判断否存在大于当前节点子节点，如果不存在 ，则堆本身是平衡的，不需要调整；如果存在，则将最大的子节点与之交换，交换后，如果这个子节点还有子节点，则要继续按照同样的步骤对这个子节点进行调整*/for(parent=index; (parent*2+1)<heap.size; parent=child) {child=parent*2+1;//取两个子节点中的最大的节点if(((child+1)<heap.size)&&(heap.arr[child]<heap.arr[child+1])) {child++;}//判断最大的节点是否大于当前的父节点if(cur>=heap.arr[child]) {//不大于，则不需要调整，跳出循环break;}else {//大于当前的父节点，进行交换，然后从子节点位置继续向下调整heap.arr[parent]=heap.arr[child];heap.arr[child]=cur;}}
}

🚀六、归并排序

算法精炼：归并排序是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分为(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)

分治法：【算法篇C++实现】五大常规算法

可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）：

1. 分阶段：可以理解为就是递归拆分子序列的过程，递归深度为log2n。
2. 治阶段：**即合并相邻有序子序列：**我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。

C语言代码实现：

#include <stdio.h>
#include<string.h>
void MergeAdd(int arr[], int left, int mid, int right, int *temp)
{int lmin = left; //指向左边数组最小元素位置int rmin = mid;  //指向右边数组最小元素位置（实参是mid+1）int index = left; //临时数组下标while (lmin<mid && rmin<=right){if (arr[lmin] < arr[rmin]){temp[index++] = arr[lmin++];	}else{temp[index++] = arr[rmin++];}}//如果是右边数组先移完while (lmin < mid)temp[index++] = arr[lmin++];//如果是左边数组先移完while (rmin <= right)temp[index++] = arr[rmin++];memcpy(arr + left, temp + left, sizeof(int)*(right - left + 1));
}void MergeSort(int arr[], int left, int right, int *temp)
{if (left <0 || arr == nullptr) return;if (left < right){int mid = (right+left)/2;MergeSort(arr, left, mid, temp);  	//左边一半递归实现MergeSort(arr, mid+1, right, temp); //右边一半递归实现MergeAdd(arr, left, mid + 1, right, temp); 	//分到最后，合并子列项}
}void PrintAddr(int arr[], int len)
{for (int i = 0; i < len; i++)printf("%d ", arr[i]);printf("\n");
}
int main()
{int arr[] = { 8,9,1,7,2,3,5,4,6,0 };int len = sizeof(arr) / sizeof(arr[0]);int *temp = new int[len];MergeSort(arr,0,len-1,temp);PrintAddr(arr, len);delete temp;
}

🚀七、快速排序

**算法精炼：**每次选取第一个数为基准数；然后将大于和小于基准的元素分别放置于基准数两边–>“乾坤大挪移”；继续分别对基准数两侧未排序的数据使用分治法进行细分处理，直至整个序列有序。

C语言代码实现：

#include <stdio.h>
int partition(int arr[], int low, int high)
{int i = low;int j = high;int base = arr[low]; //选择第一个数作为基准if (low < high){while (i < j){while (i < j && arr[j] >= base) {j--; //从右往左找到比基准数小的}if (i < j)//右边有比基数小的数（排除j<i的情况）{arr[i++] = arr[j];}while (i < j&&arr[i] < base) {i++; //从左往右找到比基准数大的}if (i < j)//左边有比基数大的数{arr[j--] = arr[i];}}arr[i] = base;}return i;
}
//快速排序
void QuickSort(int arr[], int low, int high)
{if (low < high){int index = partition(arr, low, high); //快速排序QuickSort(arr, low, index - 1); //左边一半快速排序QuickSort(arr, index + 1, high); //右边一半快速排序}
}void PrintAddr(int arr[], int len)
{for (int i = 0; i < len; i++)printf("%d ", arr[i]);printf("\n");
}
int main()
{int arr[] = { 163, 161, 158, 165, 171, 170, 163, 159, 162 };int len = sizeof(arr) / sizeof(arr[0]);QuickSort(arr, 0, len - 1);PrintAddr(arr, len);
}

⛳总结：

排序算法	平均时间复杂度	最好情况	最坏情况	排序方式	稳定性
冒泡排序	O(n * n)	O(n)	O(n * n)	In-place	稳定
选择排序	O(n * n)	O(n * n)	O(n * n)	In-place	不稳定
插入排序	O(n * n)	O(n)	O(n * n)	In-place	稳定
希尔排序	O(n * log n)	O(n * log n)	O(n * log n)	In-place	不稳定
归并排序	O(n * log n)	O(n * log n)	O(n * log n)	Out-place	稳定
堆排序	O(n * log n)	O(n * log n)	O(n * log n)	In-place	不稳定
快速排序	O(n * log n)	O(n * log n)	O(n * n)	In-place	不稳定