代码出处:
动图出处
十大经典排序算法总结（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>0
for(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中
else
A[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++ ){
//前面数组的数小,就把前面数组的数加入a
if(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逆序对的数量-------（分治，归并排序）
2333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
