2019独角兽企业重金招聘Python工程师标准>>> 
一、直接插入排序：是最简单的排序方法，算法简单来说就是可以把第一个数a[0]看做有序数组，那么a[1]要插入进来，对比，插入合适位置；然后a[0],a[1]是有序数组，插入a[2]就依次和a[0],a[1]比较并插入，若a[2]需插在最前面，那a[0],a[1]都要依次后移。。。以此类推。所以插入排序有很多比较及交换的过程。时间复杂度为O(n2)。下面是自己编的插入排序的代码，很简单嗯：
void InsertSort(int *a,int length)
{
int temp=0;
for(int i=1;i<length;i++)
{
for(int j=0;j<i;j++)
{
if(a[i]<a[j])
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
}
二、希尔排序：也是一种插入排序，但是用简单的算法有了大的复杂度改进。简单来说就是设置了一个增量表K[]。比如有一个10个数字的数组需要排序的话，可以把增量表设置成K[3]={5,3,1}。先以增量5排序，就是把10个数字数组分区成为{R1，R6};{R2，R7};{R3，R8};{R4，R9};{R5，R10}.区域内各自使用插入排序，然后再以增量3排序，最后一定要用增量1排序，确认整体的顺序正确。这样可以因为小区域内的简单排序，确保整个数组”基本有序“，最后再进行一次校验，校验的时候就不需要过多的交换而浪费时间。但是希尔排序的复杂度很难分析，和增量序列也有关系。姑且记住当增量序列dlta[k]=2t-k+1-1时，其复杂度为O（n3/2）。
void ShellSort(int *array,int *dk,int length)
{
for(int i=0;i<sizeof(dk);i++)
{
ShellFastSort(array,dk[i],length);
}
}
void ShellFastSort(int *a,int k, int len)
{
int temp;
for(int i=0;i<k;i++)
{
for(int j=i+k;j<len;j+=k)
{
for(int m=i;m<j;m+=k)
if(a[m]>a[j])
{
temp=a[j];
a[j]=a[m];
a[m]=temp;
}
}
}
}
三、冒泡排序：经典排序算法，交换的思想。数与数依次比较，大的就往后移，第一趟排序能把最大的数交换到最后一个位置，第二趟把第二大的数字交换到倒数第二的位置。。。时间复杂度还是O（n2）.
for(int j=n;j>0;j--)
{
for(int i=1;i<j;i++)
{
if(array[i-1]>array[i]){
temp=array[i];
array[i]=array[i-1];
array[i-1]=temp;
}
}
}
四、快速排序：是对冒泡排序的改进，思想简单来说，一趟排序把数字分成大数字区域和小数字区域，间隔点也就是所谓的“枢轴（pivot）“可任意选。通常把第一个数字作为枢轴，划分成两个区域后，再各自划分，不断递归，最后就剩两个或三个数字的区域，就很简单就能排列出来了。（不过代码还是稍微纠结了一下才写出来啊。。。）栈的最大深度可降为O（logn）
void FastSort(int *a,int low,int high)
{
int pivotloc=0;
if(low<high){
pivotloc=partition(a,low,high);
FastSort(a,low,pivotloc-1);
FastSort(a,pivotloc+1,high);
}
}
int partition(int *a,int low,int high)
{
int pivotkey=a[low],temp;
while(low<high){
while(low<high&&a[high]>=pivotkey){high--;}
if(low<high)
a[low++]=a[high];
while(low<high&&a[low]<=pivotkey){low++;}
if(low<high)
a[high--]=a[low];
}
return low;
}
