其实深入解析：八大经典排序算法详解的问题并不复杂，但是又很多的朋友都不太了解，因此呢，今天小编就来为大家分享深入解析：八大经典排序算法详解的一些知识，希望可以帮助到大家，下面我们一起来看看这个问题的分析吧！
当n很大时，应该使用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。
快速排序：目前认为是基于比较的内部排序中最好的方法。当待排序关键字随机分布时，快速排序的平均时间最短；
1.插入排序——直接插入排序
基本理念：
向已排序的有序列表中插入一条记录，得到一个新的有序列表，记录数加1。即：先将序列的第一条记录视为有序子序列，然后逐条插入第二条记录，直到整个序列是有序的。
要点：设置哨兵，用于临时存储和判断数组边界。
直接插入排序示例：
如果遇到与插入元素相等的元素，则插入元素将要插入的元素放在相等元素之后。因此，相等元素的顺序没有改变。原来的无序序列的顺序就是排序后的顺序，所以插入排序是稳定的。
算法的实现：
[cpp]查看纯文本
打印？
voidprint(inta[],intn,inti){
库特
for(intj=0;j8;j++){
库特
}
库特
}
voidInsertSort(inta[],intn)
{
为（inti=1;我
if(a[i]a[i-1]){//如果第i个元素大于第i-1个元素，则直接插入。如果小于，则移动已排序的列表并插入。
intj=i-1；
intx=a[i];//复制为哨兵，存放要排序的元素
a[i]=a[i-1];//逐个移动一个元素
while(xa[j]){//在有序列表中查找插入位置
a[j+1]=a[j];
j--;//将元素向后移动
}
a[j+1]=x； //插入到正确的位置
}
print(a,n,i);//打印每次排序的结果
}
}
intmain(){
inta[8]={3,1,5,7,2,4,9,6};
插入排序(a,8);
打印（a,8,8）；
}
效率：
时间复杂度：O(n^2)。
其他插入排序包括二元插入排序和2路插入排序。
2.插入排序——希尔排序（Shell`s Sort）
希尔排序法是由D.L. 提出的。 Shell于1959年提出，是对直接排序的很大改进。希尔排序也称为减少增量排序。
基本思想：
首先，将整个待排序记录序列分成若干子序列进行直接插入排序。当整个序列中的记录“基本有序”时，则直接对所有记录进行插入排序。
操作方法：
选择增量序列t1,t2,tk，其中titj,tk=1；
根据增量序列数k对序列进行k次排序；
在每次排序过程中，将待排序列根据对应的增量ti分成若干个长度为m的子序列，对每个子表进行直接插入排序。只有当增量因子为1时，整个序列才被当作一个表来处理，表的长度就是整个序列的长度。
希尔排序示例：
算法实现：
我们简单处理增量序列：增量序列d={n/2,n/4, n/8.1}n 为要排序的数字个数
即：首先将一组待排序记录按照一定的增量d（n/2，n为待排序数的个数）划分为若干组子序列，每组记录的下标相差d.对于每组中的所有记录元素通过直接插入进行排序，然后按更小的增量（d/2）进行分组，并在每组内再次排序。继续减少增量，直到为1，最后使用直接插入排序完成排序。
[cpp]查看纯文本
打印？
voidprint(inta[],intn,inti){
库特
for(intj=0;j8;j++){
库特
}
库特
}
/**
*直接插入排序的一般形式
*@paramintdk 减少增量。如果是直接插入排序，dk=1
*/
voidShellInsertSort(inta[],intn,intdk)
{
为（inti=dk;i
if(a[i]a[i-dk]){//如果第i个元素大于第i-1个元素，则直接插入。如果小于，则移动已排序的列表并插入。
intj=i-dk；
intx=a[i];//复制为哨兵，存放要排序的元素
a[i]=a[i-dk];//先向后移动一个元素
while(xa[j]){//在有序列表中查找插入位置
a[j+dk]=a[j];
j-=dk;//向后移动元素
}
a[j+dk]=x； //插入到正确的位置
}
打印（a，n，i）；
}
}
/**
*首先按照增量d进行希尔排序（n/2，n为要排序的数字个数）
*/
voidshellSort(inta[],intn){
intdk=n/2；
而（dk=1）{
ShellInsertSort(a,n,dk);
dk=dk/2；
}
}
intmain(){
inta[8]={3,1,5,7,2,4,9,6};
//ShellInsertSort(a,8,1);//直接插入排序
shellSort(a,8);//希尔插入排序
打印（a,8,8）；
}
希尔排序时效性分析比较困难。键码比较的次数和记录的移动的次数取决于增量因子序列d的选择。在某些情况下，可以准确估计键码比较次数和记录的走法次数。目前还没有人给出一种选择最佳增量因子序列的方法。增量因子序列可以通过多种方式获取，包括奇数和素数。但需要注意的是，增量因子之间除1外没有其他公共因子，最后的增量因子必须为1。希尔排序方法是一种不稳定的排序方法。
3. 选择排序——简单选择排序
基本思想：
在一组待排序的数字中，选择最小（或最大）的数字，与第一个位置的数字交换；然后找到剩余数字中最小（或最大）的数字，并将其与第二位置的数字交换。交换，以此类推，直到第n-1个元素（倒数第二个数字）和第n个元素（最后一个数字）进行比较。
简单选择排序的示例：
操作方法：
第一遍，找到n条记录中关键码最小的记录，与第一条记录交换；
第二遍，从第二条记录开始的n-1条记录中选择关键码最小的记录，与第二条记录交换；
等等.
对于第i遍，从第i条记录开始的n-i+1条记录中选择具有最小密钥码的记录并与第i条记录交换。
直到整个序列按key排序。
算法实现：
[cpp]查看纯文本
打印？
voidprint(inta[],intn,inti){
库特斯
for(intj=0;j8;j++){
库特
}
库特
}
/**
*数组的最小值
*@returnint 数组键值
*/
intSelectMinKey(inta[],intn,inti)
{
intk=i；
for(intj=i+1;jn;++j){
如果(a[k]a[j])k=j;
}
返回k；
}
/**
*选择排序
*/
voidselectSort(inta[],intn){
intkey，tmp；
for(inti=0;in;++i){
key=SelectMinKey(a,n,i);//选择最小的元素
如果（键！=i）{
tmp=a[i];a[i]=a[key];a[key]=tmp;//最小元素与第i个元素互换
}
打印（a，n，i）；
}
}
intmain(){
inta[8]={3,1,5,7,2,4,9,6};
cout"初始值：";
for(intj=0;j8;j++){
库特
}
库特
选择排序(a,8);
打印（a,8,8）；
}
简单选择排序的改进—— 二元选择排序
在简单选择排序中，每次循环只能确定排序后一个元素的位置。我们可以考虑改进每次循环对两个元素（当前最大和最小记录）的定位，从而减少排序所需的循环次数。改进后，排序n个数据最多只需要[n/2]次循环。具体实现如下：
[cpp]查看纯文本
打印？
voidSelectSort(intr[],intn){
inti,j,最小值，最大值，tmp;
for(i=1;i=n/2;i++){
//进行不超过n/2次的选择排序操作
min=i;max=i;//分别记录最大最小关键字记录位置
for(j=i+1;j=n-i;j++){
if(r[j]r[最大值]){
最大=j;继续；
}
如果（r[j]r[分钟]）{
最小值=j；
}
}
//这个交换操作也可以具体情况具体讨论，提高效率。
tmp=r[i-1];r[i-1]=r[min];r[min]=tmp;
tmp=r[n-i];r[n-i]=r[max];r[max]=tmp;
}
}
4.选择排序——堆排序
堆排序是一种树选择排序，是对直接选择排序的有效改进。
基本思想：
堆的定义如下：n个元素的序列(k1,k2,kn)，当且仅当
它被称为堆。从堆的定义可以看出，堆顶元素（即第一个元素）一定是最小项（小顶堆）。
如果将堆存储为一维数组，则堆对应于一棵完全二叉树，所有非叶子节点的值不大于（或不小于）其子节点的值，根节点（堆顶元素）的值最小（或最大）。喜欢：
(a) 大顶堆序列：(96,83,27,38,11,09)
(b) 小顶堆序列：(12, 36, 24, 85, 47, 30, 53, 91)
最初，将待排序的n个数的序列视为一个顺序存储的二叉树（一维数组存储二叉树），调整它们的存储顺序，使其成为一个堆，输出堆顶元素即可得到n 个元素。堆中最小（或最大）的元素，则堆的根节点数最小（或最大）。然后重新调整前（n-1）个元素组成堆，输出堆顶元素，得到n个元素中第二小（或第二大）的元素。依此类推，直到出现一个只有两个节点的堆，将它们交换，最后得到n个节点的有序序列。将此过程称为堆排序。
因此，实现堆排序需要解决两个问题：
1.如何构建n个要排序的数字到堆中；
2、输出堆顶元素后，如何调整剩余的n-1个元素，使其成为新的堆。
我们先讨论第二个问题：输出堆顶元素后，用剩余的n-1个元素重建堆的调整过程。
如何调整小顶堆：
1）有一个有m个元素的堆。输出堆顶元素后，还剩下m-1个元素。堆底的元素被发送到堆顶（（最后一个元素与堆顶交换），堆被销毁。唯一的原因是根节点不满足属性堆的。
2）将根节点与左右子树中较小的元素交换。
3）如果与左子树交换：如果左子树堆被破坏，即左子树的根节点不满足堆的属性，则重复方法（2）。
4）如果与右子树交换，如果右子树堆被破坏，即右子树的根节点不满足堆的性质。然后重复方法（2）。
5）继续对不满足堆属性的子树进行上述交换操作，直到叶子节点和堆构建完毕。
这种从根节点到叶节点的调整过程称为筛选。如图所示：
我们来讨论一下最初构建一个包含n 个元素的堆的过程。
堆建法：初始序列建堆的过程是一个反复筛选的过程。
1）一棵有n个节点的完全二叉树，那么最后一个节点就是
节点的子树。
2) 过滤
从以节点为根的子树开始，子树变成堆。
3）然后，按顺序向前过滤以每个节点为根的子树，并将它们形成堆，直到根节点。
如图所示，构建堆的初始过程：无序序列：(49,38,65,97,76,13,27,49)
算法的实现：
从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶和堆最后一个元素之间交换位置。所以堆排序由两个函数组成。一是构建堆的穿透函数，二是重复调用穿透函数实现排序的函数。
[cpp]查看纯文本
打印？
voidprint(inta[],intn){
为（intj=0;j
库特
}
库特
}
/**
*已知H[s.m]除H[s]外均满足堆的定义
*调整H[s]使其成为一个大的顶堆。即将过滤以第s个节点为根的子树，
*@paramH是要调整的堆数组
*@params为要调整的数组元素的位置
*@paramlength是数组的长度
*/
voidHeapAdjust(intH[],ints,intlength)
{
inttmp=H[s];
intchild=2*s+1;//左子节点的位置。 （i+1为当前调整节点右子节点的位置）
while(子长度){
如果（孩子+1
++孩子；
}
如果（H[s]
H[s]=H[child];//然后将较大的子节点上移，替换其父节点
s=child;//重置s，即下一个要调整的节点的位置
子=2*s+1；
}else{//如果当前要调整的节点大于其左右子节点，则无需调整，直接退出
休息；
}
H[s]=tmp;//将当前要调整的节点放到比它大的子节点位置。
}
打印（高度，长度）；
}
/**
*初始堆调整
* 将H[0.length-1] 构建成堆
*调整后第一个元素为序列中最小的元素
*/
voidBuildingHeap(intH[],intlength)
{
//最后一个有子节点的位置i=(length-1)/2
for(inti=(长度-1)/2;i=0;--i)
HeapAdjust(H,i,长度);
}
/**
*堆排序算法
*/
voidHeapSort(intH[],intlength)
{
//初始堆
BuildingHeap(H,长度);
//调整从最后一个元素开始的顺序
for(inti=长度-1;i0;--i)
{
//交换堆顶元素H[0]和堆最后一个元素
inttemp=H[i];H[i]=H[0];H[0]=温度；
//每次交换堆顶元素和堆最后一个元素后，必须对堆进行调整
堆调整(H,0,i);
}
}
intmain(){
intH[10]={3,1,5,7,2,4,9,6,10,8};
cout"初始值：";
打印（H，10）；
堆排序(H,10);
//选择排序(a,8);
cout"结果：";
打印（H，10）；
}
分析：
设树深度为k。从根到叶子过滤时，元素比较次数最多为2(k-1)次，记录最多交换k次。因此，堆建好后，排序过程中的筛选次数不超过以下公式：
构建堆时的比较次数不超过4n，因此堆排序最坏情况的时间复杂度为：O(nlogn)。
5.交换排序——冒泡排序（Bubble Sort）
基本思想：
在一组待排序的数字中，对范围内所有尚未排序的数字，从上到下依次比较和调整相邻的两个数字，使较大的数字向下沉，较大的数字向下沉。小的向上升起。即：每当比较两个相邻的数字，发现它们的排序与排序要求相反时，就将它们交换。
冒泡排序示例：
算法的实现：
[cpp]查看纯文本
打印？
voidbubbleSort(inta[],intn){
for(inti=0;in-1;++i){
for(intj=0;jn-i-1;++j){
如果（a[j]a[j+1]）
{
inttmp=a[j];a[j]=a[j+1];a[j+1]=tmp;
}
}
}
}
冒泡排序算法的改进
冒泡排序常见的改进方法是添加符号变量交换，用于标记某个排序过程中是否存在数据交换。如果在某个排序过程中没有发生数据交换，则说明数据已按要求排列。 OK，排序可以立即结束，避免不必要的比较过程。本文提供了以下两种改进算法：
1. 设置一个地标变量pos 来记录每次排序过程中最后一次交换的位置。由于pos 位置之后的记录已就位交换，因此在下一次排序过程中仅扫描pos 位置。
改进后的算法如下：
[cpp]查看纯文本
打印？
voidBubble_1(intr[],intn){
inti=n-1;//初始时，最终位置保持不变
而（i0）{
intpos=0;//每行开始时，无记录交换
for(intj=0;ji;j++)
如果（r[j]r[j+1]）{
pos=j;//记录兑换位置
inttmp=r[j];r[j]=r[j+1];r[j+1]=tmp;
}
i=pos;//为下一步排序做准备
}
}
2.传统冒泡排序中，每次排序操作只能找到一个最大值或最小值。我们考虑采用在每次排序操作中进行正向冒泡和反向冒泡的方法，一次性获得两个最终值（最大的一个）。和最小的）
，从而将排序次数减少了近一半。
改进后的算法实现为：
[cpp]查看纯文本
打印？
voidBubble_2(intr[],intn){
intlow=0;
inthigh=n-1;//设置变量的初始值
inttmp，j；
而（低高）{
for(j=low;jhigh;++j)//正向冒泡，找到最大的
如果（r[j]r[j+1]）{
tmp=r[j];r[j]=r[j+1];r[j+1]=tmp;
}
--high;//修改high值，向前移动一位
for(j=high;jlow;--j)//反转气泡找出最小的
如果（r[j]
tmp=r[j];r[j]=r[j-1];r[j-1]=tmp;
}
++low;//修改low值，向后移动一位
}
}
6.交换排序——快速排序
基本思想：
1）选择一个基本元素，通常是第一个元素或最后一个元素，
2）通过一轮排序，将待排序的记录分为两个独立的部分，并且其中一部分记录的元素值小于参考元素值。另一部分记录大于基值的元素值。
3）此时，参考元素排序后已处于正确位置。
4）然后继续用同样的方式对两部分记录进行排序，直到整个序列有序。
快速排序示例：
(a) 一次排序过程：
(b) 排序全过程
算法的实现：
递归实现：
[cpp]查看纯文本
打印？
voidprint(inta[],intn){
为（intj=0;j
库特
}
库特
}
voidswap(int*a,int*b)
{
inttmp=*a;
*a=*b；
*b=tmp；
}
intpartition(inta[],intlow,inthigh)
{
intprivotKey=a[low];//基本元素
while(lowhigh){//从表格两端向中间交替扫描
while(lowhigha[high]=privotKey)--high;//从high指向的位置向前搜索，一直到low+1的位置。将小于底端的元素交换到下端
交换（a[低]，a[高]）；
while(lowhigha[low]=privotKey)++low;
交换（a[低]，a[高]）；
}
打印（a，10）；
回报低；
}
voidquickSort(inta[],intlow,inthigh){
如果（低高）{
intprivotLoc=partition(a,low,high);//将表分为两部分
fastSort(a,low,privotLoc-1);//递归排序low子表
fastSort(a,privotLoc+1,high);//递归排序high子表
}
}
intmain(){
inta[10]={3,1,5,7,2,4,9,6,10,8};
cout"初始值：";
打印（a，10）；
快速排序(a,0,9);
cout"结果：";
打印（a，10）；
}
分析：
快速排序通常被认为是同数量级排序方法中平均性能最好的（O(nlog2n)）。但如果初始序列是按键排序或者基本排序的话，快速排序就会退化为冒泡排序。为了改进它，通常采用“三合一法”来选择基准记录，即将以两个端点为中心的三个记录键和排序区间的中点调整为支点记录。快速排序是一种不稳定的排序方法。
快速排序改进
在该改进算法中，仅对长度大于k的子序列递归调用快速排序，使原始序列基本有序，然后使用插入排序算法对整个基本有序序列进行排序。实践证明，改进算法的时间复杂度有所降低，且当k取8左右时，改进算法性能最佳。算法思想如下：
[cpp]查看纯文本
打印？
voidprint(inta[],intn){
为（intj=0;j
库特
}
库特
}
voidswap(int*a,int*b)
{
inttmp=*a;
*a=*b；
*b=tmp；
}
intpartition(inta[],intlow,inthigh)
{
intprivotKey=a[low];//基本元素
while(lowhigh){//从表格两端向中间交替扫描
while(lowhigha[high]=privotKey)--high;//从high指向的位置向前搜索，一直到low+1的位置。将小于底端的元素交换到下端
交换（a[低]，a[高]）；
while(lowhigha[low]=privotKey)++low;
交换（a[低]，a[高]）；
}
打印（a，10）；
回报低；
}
voidqsort_improve(intr[],intlow,inthigh,intk){
if(high-lowk){//长度大于k时递归，k为指定数字
intpivot=partition(r,low,high);//调用的Partition算法不变
qsort_improve(r,低，pivot-1,k);
qsort_improve(r,枢轴+1,高，k);
}
}
voidquickSort(intr[],intn,intk)
{ qsort_improve(r,0,n,k);//先调用改进算法Qsort使之基本有序 //再用插入排序对基本有序序列排序 for(inti=1; i<=n;i ++){ inttmp = r[i]; intj=i-1; while(tmp < r[j]){ r[j+1]=r[j]; j=j-1; } r[j+1] = tmp; } } intmain(){ inta[10] = {3,1,5,7,2,4,9,6,10,8}; cout<<"初始值："; print(a,10); quickSort(a,9,4); cout<<"结果："; print(a,10); } 7. 归并排序（Merge Sort） 基本思想： 归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。 归并排序示例： 合并方法： 设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为n-i +1、n-m。 j=m+1；k=i；i=i; //置两个子表的起始下标及辅助数组的起始下标 若i>m 或j>n，转⑷ //其中一个子表已合并完，比较选取结束 //选取r[i]和r[j]较小的存入辅助数组rf 如果r[i] 否则，rf[k]=r[j]； j++； k++； 转⑵ //将尚未处理完的子表中元素存入rf 如果i<=m，将r[i…m]存入rf[k…n] //前一子表非空 如果j<=n , 将r[j…n] 存入rf[k…n] //后一子表非空 合并结束。 [cpp]view plaincopy print? //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n] voidMerge(ElemType *r,ElemType *rf,inti,intm,intn) { intj,k; for(j=m+1,k=i; i<=m && j <=n ; ++k){ if(r[j] < r[i]) rf[k] = r[j++]; elserf[k] = r[i++]; } while(i <= m) rf[k++] = r[i++]; while(j <= n) rf[k++] = r[j++]; } 归并的迭代算法 1 个元素的表总是有序的。所以对n 个元素的待排序列，每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表，所得子表除最后一个子表长度可能为1 外，其余子表长度均为2。再进行两两合并，直到生成n 个元素按关键码有序的表。 [cpp]view plaincopy print? voidprint(inta[],intn){ for(intj= 0; j cout< } cout< } //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n] voidMerge(ElemType *r,ElemType *rf,inti,intm,intn) { intj,k; for(j=m+1,k=i; i<=m && j <=n ; ++k){ if(r[j] < r[i]) rf[k] = r[j++]; elserf[k] = r[i++]; } while(i <= m) rf[k++] = r[i++]; while(j <= n) rf[k++] = r[j++]; print(rf,n+1); } voidMergeSort(ElemType *r, ElemType *rf,intlenght) { intlen = 1; ElemType *q = r ; ElemType *tmp ; while(len < lenght) { ints = len; len = 2 * s ; inti = 0; while(i+ len Merge(q, rf, i, i+ s-1, i+ len-1 );//对等长的两个子表合并 i = i+ len; }
【深入解析：八大经典排序算法详解】相关文章：
用户评论
这篇文章一定介绍了常见的几种排序算法吧？
有9位网友表示赞同！
我最想了解一下这个算法的时间复杂度是怎样的。
有14位网友表示赞同！
我需要学习一些排序算法的相关知识，这篇博客看起来很合适。
有15位网友表示赞同！
不同类型的排序算法应用场景差别很大吧？这篇文章会不会讲到?
有20位网友表示赞同！
八大排序算法？听起来很有深度的样子！
有12位网友表示赞同！
我已经学过冒泡排序和插入排序了，不知道还有哪些不同的方法呢？
有11位网友表示赞同！
这篇博文是科普性质的文章吗？还是更偏向理论讲解？
有20位网友表示赞同！
看完这篇文章后我想试试自己实现一下这些算法。
有12位网友表示赞同！
我之前一直用python自带的排序函数，没想过学习具体的排序算法原理。
有7位网友表示赞同！
数据结构和算法是计算机科学的基础知识吧？这篇文章很有帮助！
有18位网友表示赞同！
学习完这些排序算法后，可以写更快的程序吗？
有18位网友表示赞同！
算法真的很重要，需要不断学习新的知识才能提升技能。
有20位网友表示赞同！
这篇博客是否对不同编程语言中的排序算法都做了介绍？
有19位网友表示赞同！
我感兴趣的是快速排序的具体实现步骤。希望这篇文章能详细讲解.
有11位网友表示赞同！
学习这些算法可以帮助我更好地理解代码背后的逻辑吗？
有10位网友表示赞同！
最近在学习算法，刚好需要了解这些排序算法，来就对了！
有18位网友表示赞同！
有没有什么好的资料可以推荐，深入了解这些排序算法呢？
有16位网友表示赞同！
这种排序算法都适用于哪些场景？文章里会不会讲?
有19位网友表示赞同！
我会把这篇文章分享给我的同学一起学习。
有16位网友表示赞同！