java各种排序算法

/**
1.直接插入排序
算法思想：将第n个数插入到前n个已经排好序的数组当中，这种排序方式适合n的数字不太大的情况，并且数组基本有序。
时间复杂度O(n2);
*/
public static void  InsertSort(int a[]){
if(a==null || a.length==0) return;
for(int i=1;i<a.length;i++){
int j=i-1;
int temp=a[i];
while(j>=0&&j<=a.length-1&&a[j]>temp){
a[j+1]=a[j];
j--;
}
a[j+1]=temp;
}
}

/**
2.折半插入排序，这个排序的算法只是减少了查找的时间，时间复杂度为O(n2)
*/

public static void BinSort(int a[]){
if(a==null || a.length==0) return;
for(int i=1;i<a.length;i++){
int low=0;
int high=i-1;
int temp=a[i];
while(low<=high){

int mid=(low+high)>>1;

if(a[mid]>temp) high=mid-1;

else low=mid+1;
}

for(int j=i-1;j>=low;j--){
a[j+1]=a[j];
}
a[low]=temp;
}
}
/**
3.希尔排序,时间复杂度为O(n1.5),
*/

//传特定参数的希尔排序
public static void shellPass(int a[],int delt){
for(int i=delt;i<a.length;i++){
if(a[i]<a[i-delt]){
int temp=a[i];
int j=i-delt;
for(;j>=0&&temp<a[j];j-=delt){
a[j+delt]=a[j];
}
a[j+delt]=temp;
}
}
}

public static void ShellSort(int a[],int delt[]){
if(a==null || a.length==0) return;

for(int i=0;i<delt.length;i++){
shellPass(a,delt[i]);
}

}
/**
冒泡排序，时间复杂度为O(n2),
*/
public static void BubbleSort(int a[]){
if(a==null || a.length==0) return;
for(int i=0;i<a.length-2;i++){
for(int j=0;j<a.length-1-i;j++){
if(a[j+1]<a[j]){
int temp=a[j+1];
a[j+1]=a[j];
a[j]=temp;
}
}
}
}

/**
快速排序，性能最差的时候，时间复杂度O(n2),但是平均性能最好
*/
public static int QuickPass(int a[],int low,int high){

int flag=a[low];
while(low<high){
while(low<high&&flag<a[high])  high--;
if(low<high){
a[low]=a[high];low++;
}
while(low<high&&flag>a[low]) low++;
if(low<high){
a[high]=a[low];high--;
}
}
a[low]=flag;
return low;
}

public static void QuickSort(int a[],int low,int high){
if(a==null || a.length==0) return;
if(low<high){
int pos=QuickPass(a,low,high);
QuickSort(a,low,pos-1);
QuickSort(a,pos+1,high);
}

}

/**
简单选择排序
*/

public static void SimpleSelectSort(int a[]){
if(a==null || a.length==0) return;
for(int i=0;i<a.length-1;i++){
int k=i;
for(int j=i+1;j<=a.length-1;j++){
if(a[j]<a[k]) k=j;
}
if(k!=i){
int temp=a[k]; a[k]=a[i];a[i]=temp;
}
}
}

/**
堆排序，时间复杂度为O(nlogn),平均时间复杂度也是O(nlogn),适合数目不太大的排序，大是相对于快速排序数目要大得多，相对于归并排序就小了，
*/
//大堆根
public static void Sift(int a[],int low,int high){
int i=low;
int j=i*2+1;

int temp=a[i];

boolean finish=false;
while(!finish&&j<=high){
if(j+1<=high&&a[j+1]>a[j]){
j=j+1;
}
if(temp>a[j])  finish=true;
else{
a[i]=a[j];
i=j;
j=2*i+1;
}
}
a[i]=temp;
}

//建初堆
public static void Cre_Heap(int a[]){
for(int i=(a.length-1)/2;i>=0;i--){
Sift(a,i,a.length-1);
}
}

//堆排序
public static void HeapSort(int a[]){
if(a==null || a.length==0) return;
Cre_Heap(a);
for(int i=a.length-1;i>=1;i--){
int temp=a[0];
a[0]=a[i];
a[i]=temp;
Sift(a,0,i-1);
}
}

/**
2路-归并排序
*/

//将a数组low-mid，和mid+1-high合并到b中
public static void Merge(int a[],int low,int mid,int high,int b[]){
int i=low,j=mid+1,k=low;
while((i<=mid)&&(j<=high)){
if(a[i]<=a[j]){
b[k]=a[i];
i++;
}
else{
b[k]=a[j];
j++;
}
k++;
}
while(i<=mid){
b[k]=a[i];
i++;k++;
}
while(j<=high){
b[k]=a[j];
k++;j++;
}
}
//通过递归调用实现不断的合并最后达到排序的目的
public static void MergeSort(int a[],int low,int high,int c[]){
if(a==null || a.length==0) return;
int b[]=new int[a.length];
if(low==high) c[low]=a[low];
else{
int mid=(low+high)>>1;
MergeSort(a,0,mid,b);
MergeSort(a,mid+1,high,b);
Merge(b,0,mid,high,c);
}

}
}

排序方法的稳定性，  简单排序中只有“简答选择排序”是不稳定的，性能好的排序 有“快速排序”，"希尔排序"，"堆排序"，"归并排序"，"基数排序"，其中“快速排序”，"希尔排序"，"堆排序"是不稳定的排序，  当数量级较小的时候，可以使用简单排序，当序列基本有序的时候，“直接插入排序”性能较好，当数量较大，但是移动次数较少的时候，可以使用“简单选择排序”，“快速排序”的平均性能是性能好的排序方法里面性能最好的，但是“快速排序”的最差性能达到O(n2), ”希尔排序“是对“直接插入排序”的改进，直接插入排序是在序列基本有序的时候，性能较高，”希尔排序“当参数为1的时候就是“直接插入排序”，“堆排序”是对树形排序的改进，树形排序需要额外的n-1个存储空间，堆排序则优化了需要O(1)辅存，“堆排序”的平均时间复杂度，最坏时间复杂度都是O(nlogn),但是当n较大的时候，其性能不及“归并排序”，“归并排序”的最坏时间复杂度和平均时间复杂度也是O(nlogn),但是由于要附加和待排序列等数量的空间，所以很少用到内部排序，一般用在外部排序中，“基数排序”采用“低位优先”的排序策略，通过反复进行分配和收集，完成排序，“基数排序”的最坏时间复杂度和平均时间复杂度都是O(dn)，其中d是数字的位数。要用的辅助存储是O(rd),其中rd是各位数字的取值范围。

综上所述，所有的排序方法都存在优缺点，在选取排序算法的时候，一般要把多种排序算法结合起来一起使用，达到效率的最佳。