代码出处:

动图出处

插入排序

直接插入排序：

步骤：

动图：

代码：

折半插入排序：

注意点：

流程：

代码：

希尔排序：

过程：

交换排序：

冒泡排序：

性能分析：

动图：

代码：

进阶版：

快速排序（代码很容易考）：

算法思想:

代码：

选择排序：

简单选择排序：

代码：

堆排序:

堆的定义:

建立大根堆 :

代码:

在堆中插入元素:

在堆中删除元素:

归并排序

合并的过程:

代码:

将两个函数合并:

归并排序运用：

题解：

代码出处:

数据结构---排序_就是爱喝百香果冷饮的博客-CSDN博客

动图出处

十大经典排序算法总结（Java实现+动画）_meibenxiang的博客-CSDN博客_java 排序算法

插入排序

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

直接插入排序：

步骤：

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤2~5。

动图：

代码：

带哨兵：

//直接插入排序(王道）
void InsertSort(Elementype A[],int n)
{int i,j;for(i=2;i<=n;i++) //依次将A[2]~A[n]插入到前面已排序序列if(A[i].key<A[i-1].key) //若A[i]的关键码小于其前驱，需将A[i]插入有序表 {A[O]=A[i];//复制为哨兵，A[0]不存放元素 for(j=i-1;A[O].key<A[j].key;--j) //从后往前查找待插入位置A[j+1]=A[j];A[j+1]=A[0];//复制到插入位置 }
}

不带哨兵：

j最小可以取到-1，至于为什么可以看我写的解释：

针对for循环结束后i的变化的深入研究_造船大学蒟蒻小菜鸡的博客-CSDN博客

折半插入排序：

折半插入排序实际是直接插入排序的优化，直接插入排序是将元素依次与A[0]比较来找到插入位置而折半插入排序，先用折半查找找到应该插入的位置，再移动元素

比起“直接插入排序”，比较关键字的次数减少，但是移动元素的次数没变，整体来看

时间复杂度依然是O(n^2)

low最后指向的是我们要插入的位置

注意点：

当low>high时折半查找停止，应将[low, i-1]内的元素全部右移，并将A[0]复制到 low所指位置

当A[mid]==A[0]时，为了保证算法的“稳定性”，应继续在mid所指位置右边寻找插入位置：

比如这里的60’本来就在60的右面，当A[mid]==A[0]时，应继续在mid所指位置右边寻找插入位置。

流程：

代码：

void InsertSort(ElemType A[],int n)
{int i,j,low,high,mid;for(i=2;i<=n;i++) //依次将A[2]~A[n]插入前面的已排序序列 {A[0]=A[i];//将A[i]暂存到A[0]中low=1;high=i-1;//设置折半查找的范围while(low<=high)//折半查找（默认递增有序） {mid=(low+high)/2;//取中间值if(A[mid].key>A[0].key) high=mid-1;//查找左半子表else low=mid+1;//查找右半子表  }//low就是寻找的要插入的位置for(j=i-1;j>=low;--j)A[j+1]=A[j];//统一后移元素，空出插入位置A[low]=A[0];//插入操作 }
}

希尔排序：

先将待排序表分割成若干形如L[i, i + d,i + 2d... i + kd]的“特殊”子表，对各个子表分别进行直接插入排序。缩小增量d重复上述过程，直到d=1为止。

时间复杂度︰和增量序列d;, d2, d3...的选择有关，目前无法用数学手段证明确切的时间复杂度

最坏时间复杂度为O(n2)，当n在某个范围内时，可达O(n1.3)

不稳定算法，且只能基于顺序表，不能用于链表。

过程：

第一趟d1=4，d1=总共8个元素/2=4

最后一遍时，整个表呈现基本有序，利于我们进行直接插入排序

考试会考核给定增量d给出排序后的数组。

注意看d=2时对子表进行排序的过程，它不是直接将一个子表排序好的，而是先将相邻两个元素进行排序，然后切换到下一个子表，再将相邻两个元素进行排序，一步一步完成工作。（王道版）

当然我们也可以一次性把一个子表全直接插入排序好。

代码：

//不带哨兵，易理解版
void ShellSort(int array[], int n)  //希尔排序函数
{int i, j, step;for (step = n / 2; step > 0; step = step / 2)  //这里的step步长是根据10个元素这种情况定义的{for (i = 0; i < step; i++)  //i是子表的编号{for (j = i + step; j < n; j = j + step)  //数组下标j，数组步长下标j+step{if (array[j] < array[j - step]){int temp = array[j];  //把数组下标j的值放到temp中int k = j - step;while (k >= 0 && temp < array[k]){array[k + step] = array[k];  //把大的值往后插入k = k - step;}array[k + step] = temp;  //把小的值往前插入}}}}
}

//希尔排序（王道）
void  ShellSort(ElementType A[],int n)
{//前后记录位置的增量是dk,不是1//A[0]只是存储单元，不是哨兵，当j<=0时，插入位置已到for(dk=n/2;dk>=1;dk=dk/2)//初始增量为总长度的一半，之后依次除2且向下取整 for(i=dk+1;i<=n;i++)if(A[i].key<A[i-dk].key){//需将A[i]插入有序增量子表A[0]=A[i];//暂存在A[0]//因为A[0]不是哨兵，所以这里要加上j>0for(j=i-dk;j>0 && A[0].key<A[j].key;j-=dk){//待插入关键字之前以dk为增量的关键字只要比待插入关键字大的都往后移动dk位 A[j+dk]=A[j];}A[j+dk]=A[0];//插入 }
}

交换排序：

冒泡排序：

性能分析：

稳定的算法

移动次数要和交换次数进行区分

动图：

代码：

        int[ ] array=new int[ ]{5,2,3,9,4};/*外循环为排序趟数，array.length个数进行array.length-1趟 *///由于每次外循环都会确定一个最大值，但最后一次不需要比较，所以进行array.length-1次for(int i=0;i<array.length-1;i++){/*内循环为每趟比较的次数，第i趟比较array.length-i次 */for(int j=0;j<array.length-1-i;j++){/*相邻元素比较，若满足条件则交换（升序为左大于右，降序反之） */if(array[j]>array[j+1]){int temp=array[j];array[j]=array[j+1];array[j+1]=temp;}}}

进阶版：

我们知道当一次遍历里没有发生元素交换，说明此时的数组已经是有序的，那么就可以结束。

        int[ ] array=new int[ ]{5,2,3,9,4};/*外循环为排序趟数，array.length个数进行array.length-1趟 *///由于每次外循环都会确定一个最大值，但最后一次不需要比较，所以进行array.length-1次for(int i=0;i<array.length-1;i++){//设置一个布尔型的flag变量来记录此次遍历有没有发生交换boolean  flag= false;/*内循环为每趟比较的次数，第i趟比较array.length-i次 */for(int j=0;j<array.length-1-i;j++){/*相邻元素比较，若满足条件则交换（升序为左大于右，降序反之） */if(array[j]>array[j+1]){int temp=array[j];array[j]=array[j+1];array[j+1]=temp;flag=true;//表明发生交换}}//此次遍历有没有发生交换已经有序if(flag==false) return;}

快速排序（代码很容易考）：

算法不稳定。

平均时间复杂度O（nlog2n）

最好时间复杂度时：每次选的枢轴元素都能将序列划分成均匀的两部分。

若序列原本就有序或逆序，则时、空复杂度最高(可优化，尽量选择可以把数据中分的枢轴元素。)

算法思想:

在待排序表L[1...n]中任取一个元素pivot作为枢轴(或基准，通常取首元素)，通过一趟排序将待排序表划分为独立的两部分L[1...k-1]和L[k+1..n]，使得L[1..k-1]中的所有元素小于pivot，Llk+1...n]中的所有元素大于等于pivot，则pivot放在了其最终位置L(k)上，这个过程称为一次“划分”。然后分别递归地对两个子表重复上述过程，直至每部分内只有一个元素或空为止，即所有元素放在了其最终位置上。

流程：

附加代码流程：

代码：

//快速排序（王道）
//递归的处理左右两端
void QuickSort(ElemType A[],int l,int r)
{if(l<r) // 递归跳出的条件{//Partion()是划分操作，将表划分为满足上述条件的两个子表int pivotpos=Partition(A,l,r);//找到枢轴值的位置QuickSort(A,l,pivotpos-1);//依次对两个子表进行递归排序QuickSort(A,pivotpos+1,r); }
}
//分治，假设每次总以当前表中第一个元素作为枢轴值（基准）来对表进行划分，
//则必须将表中比枢轴大的元素向右移动，将比枢轴小的元素向左移动，使得一趟
//Partition()操作后，表中的元素被枢轴一分为二。
int Partition(ElemType A[],int low,int high)
{ElemType pivot=A[low];//将当前表中第一个元素设为枢轴值，且对表进行划分while(low<high){//循环跳出条件while(low<high && A[high]>=pivot) --high;//直到找到比枢轴值小的元素否则一直--A[low]=A[high];//将比枢轴值小的元素移动到左端while(low<high && A[low]<=pivot) ++low;//同理一直++A[high]=A[low];//将比枢轴值大的元素移动到右端 } A[low]=pivot;//枢轴元素存放到最终位置return low; }

选择排序：

简单选择排序：

每一趟从序列中选最小的关键值，放到已经排好序的子序列后面。算法不稳定

代码：

//简单选择排序（王道）
void SelectSort(ElemType A[],int n)
{//对表A做简单选择排序，A[]从0开始存放元素for(i=0;i<n-1;i++)//一共进行n-1趟 {min=j;  //记录最小元素位置 for(j=i+1;j<n;j++) //在A[i...n-1]中选择最小的元素if(A[j]<A[min]) min=j;//更新最小元素位置if(min!=i) //与第i个位置交换 { int temp=A[i];A[i]=A[min];A[min]=temp;}}
}

堆排序:

关键记住：

建堆操作

向上调整和向下调整

输出堆顶元素

堆的定义:

采用一维数组进行存储，且下标从1开始

建立大根堆 :

思路:把所有非终端结点((i<=i/2)向下取整)都检查一遍，是否满足大根堆的要求(根≥左、右)，如果不满足，则进行调整将当前结点与更大的一个孩子互换

注意:

若元素互换破坏了下一级的堆，则采用相同的方法继续往下调整(小元素不断“下坠")

下面的动图包括了互换破环平衡的例子:

利用大根堆进行排序

代码:

//堆排序 （王道）
//建立大根堆（自下往上逐步调整为大根堆
void BuildMaxHeap(ElemType A[],int len)
{for(int i=len/2;i>0;i--)//从i=[n/2]~1,反复调整AdjustDown(A,i,len); }
void AdjustDown(ElemType A[],int k,int len)
{//函数AdjustDown将元素k向下进行调整A[0]=A[k] ;//A[0]暂存for(i=2*k;i<=len;i*=2)//i*2的目的是每次都比较比较k的左节点
{//沿key较大的子结点向下筛选if(i<len && A[i]<A[i+1])//如果右孩子大一些，就只要考虑和右孩子比较i++;if(A[0]>=A[i]) break;//筛选结束，如果这个元素结点值不小于它的结点值，则不需要交换else{A[k]=A[i];//将A[i]调整到双亲结点上k=i;//修改k值，以便继续向下筛选 }    } A[k]=A[0];//将筛选结点的值放入最终的位置
}
//向上调整堆
void AdjustUp(ElemType A[],int k)
{//参数k为向上调整的结点，也为堆的元素个数A[0]=A[k];int i=k/2;//若结点值大于双亲结点，则将双亲结点向下调，并继续向上比较while(i>0 && A[i]<A[0])//跳出循环{A[k]=A[i];//双亲结点下调k=i;i=k/2;//继续向上比较 } A[k]=A[0];//复制到最终位置 }
//堆排序算法
void HeapSort(ElemType A[],int len)
{BuildMaxHeap(A,len);//初始建堆for(i=len;i>1;i--){//n-1趟的交换和建堆过程Swap(A[i],A[1]);//输出堆顶元素（和堆底元素交换）AdjustDown(A,1,i-1);//整理，再把剩余的i-1个元素整理成堆 } }

在堆中插入元素:

对于小根堆，新元素放到表尾，与父节点对比,若新元素比父节点更小,则将二者互换。新元素就这样一路“上升”，直到无法继续上升为止

在堆中删除元素:

被删除的元素用堆底元素替代，然后让该元素不断“下坠”，直到无法下坠为止

归并排序

合并的过程:

将两个有序的序列合并的过程

代码:

//归并排序（王道）
ElemType *B(ElemType *)malloc(n+1)*sizeof(ElemType);//辅助数组B
void Merge(ElemType A[],int low,int mid,int high){//表A的两段A[low...mid]和A[mid+1...high]for(int i=low;i<=high;i++)B[i]=A[i];//将A中所有元素复制到B中int i,j,k;for(i=low,j=mid+1,k=i;i<=mid && j<=high;k++) {if(B[i]<=B[j])//比较B的左右两段中的元素A[k]=B[i++];//将较小值复制到A中 elseA[k]=B[j++]; }while(i<=mid) A[k++]=B[i++];//若第一个表未检测完，复制while(j<=high) A[k++]=B[j++];//若第二个表未检测完，复制
}
void MergeSort(ElemType A[],int low,int high)
{if(low<high){int mid=(low+high)/2;//从中间划分两个子序列MergeSort(A,low,mid);//对左侧子序列进行递归排序MergeSort(A,mid+1,high);//对右侧子序列进行递归排序Merge(A,low,mid,high);//归并 }}

将两个函数合并:

注意这里不要写成for(i=low,j=0;i<=mid;i++,j++) 因为此时b[low,right]都是有序的了

#include <iostream>
using namespace std;
int n;
const int N=100010;
int a[N],b[N];//a[]储存答案
void merge(int a[],int low,int high){int mid=low+high>>1;//先将整个数组分为两个有序数组if(low<high){merge(a,low,mid);merge(a,mid+1,high);}//归并int i,j,k;for(k=0,i=low,j=mid+1;i<=mid&&j<=high;k++ ){//前面数组的数小,就把前面数组的数加入aif(a[i]<=a[j])   b[k]=a[i++];else b[k]=a[j++];}while(i<=mid) b[k++]=a[i++];while(j<=high)b[k++]=a[j++];//将b[]里的数传回a[]for(i=low,j=0;i<=high;i++,j++) a[i]=b[j];
}
int main(){scanf("%d",&n);for(int i=0;i<n;i++) scanf("%d",&a[i]);merge(a,0,n-1);for(int i=0;i<n;i++) printf("%d ",a[i]);return 0;
}

归并排序运用：

Acwing788逆序对的数量-------（分治，归并排序）

题解：

Acwing788逆序对的数量-------（分治，归并排序）_造船大学蒟蒻小菜鸡的博客-CSDN博客

经典四大排序（动图实现）相关推荐

经典算法+Gif动图
0.排序算法说明 0.1 排序的定义对一序列对象根据某个关键字进行排序. 0.2 术语说明稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面: 不稳定:如果a原本在b的前面,而a=b,排 ...
图的拓扑排序(动图)
文章目录概述度的定义排序描述示例示例动图伪代码另一个实现思路概述对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序,是将G中所有顶点排成一个线 ...
数据结构七大排序算法图解——选择排序动图演示
系列文章目录四.选择排序紧接上一篇交换排序前言: 1.直接选择排序思想: 例题: 代码部分: 性能分析 2.树形选择排序思想: 例题一: 例题二: 性能分析 3.堆排序定义: 方法: 如何 ...
数据结构与算法--经典10大排序算法（动图演示）【建议收藏】
十大经典排序算法总结(动图演示) 算法分类十大常见排序算法可分为两大类: 比较排序算法:通过比较来决定元素的位置,由于时间复杂度不能突破O(nlogn),因此也称为非线性时间比较类排序非比较类型排 ...
c 语言从大到小排序算法,10 大经典排序算法（动图演示+ C 语言代码）
原标题:10 大经典排序算法(动图演示+ C 语言代码) 来源:C语言与CPP编程以前也零零碎碎发过一些排序算法,但排版都不太好,又重新整理一次,排序算法是数据结构的重要部分,系统地学习很有必要. ...
超详细八大排序+基数排序（图文并茂+动图演示+C语言代码演示）
超详细八大排序+基数排序(图文并茂+动图演示+C语言代码演示) 插入排序-直接插入排序插入排序-希尔排序选择排序-直接选择排序选择排序-堆排序交换排序-冒泡排序交换排序-快速排序-三种方法( ...
JS的十大经典算法排序
更正(2018/5/31):如果看的是原文章的话,注意希尔排序少一个等号,在本博中,我已经添加上了,希尔排序(更正后)及以前的经测试都是正确的,后面的我正找时间持续研究验证中--(过程可能有点慢) 更 ...
网上经常看到的冒泡排序的动图如何制作
今天博主想要和大家分享如何实现动态图,经常在其他博主的文章中可以看到各式各样的动图,搜索一下"网上冒泡排序的动图怎么制作出来"可以看到,很迷,全是告诉冒泡排序的原理,以及动图解析, ...
十大经典排序算法（动图演示）（转）
十大经典排序算法(动图演示) 本文转自https://www.cnblogs.com/onepixel/articles/7674659.html 0.算法概述 0.1 算法分类十种常见排序算法可以 ...

经典四大排序（动图实现）

代码出处:

动图出处

插入排序

直接插入排序：

步骤：

动图：

代码：

折半插入排序：

注意点：

流程：

代码：

希尔排序：

过程：

交换排序：

冒泡排序：

性能分析 ：

动图：

代码：

进阶版：

快速排序（代码很容易考）：

算法思想:

代码：

选择排序：

简单选择排序：

代码：

堆排序:

堆的定义:

建立大根堆 :

代码:

在堆中插入元素:

在堆中删除元素:

归并排序

合并的过程:

代码:

将两个函数合并:

归并排序运用：

题解：

经典四大排序（动图实现）相关推荐

最新文章

热门文章

性能分析：