java：排序算法

selection排序

import java.util.*;
import java.util.Comparator;

public class Solution {
private Solution(){} //初始化函数

public static void sort(Comparable[] a){
//a是升序排列
int N=a.length;
for(int i=0;i<N;i++){
int min=i; //最小元素的索引
for(int j=i+1;j<N;j++)
if(less(a[j],a[min])<0)
min=j;
exch(a,i,min);
}
}

private static int less(Comparable v,Comparable w){
return v.compareTo(w);
}

private static void exch(Comparable[] a, int i, int j){
Comparable t=a[i];a[i]=a[j];a[j]=t;
}
private static void show(Comparable[] a){
for(int i=0;i<a.length;i++)
System.out.println(a[i]+" ");
System.out.println(" ");
}
public static boolean isSorted(Comparable[] a){
//  测试元素是否有序
for(int i=1;i<a.length;i++)
if(less (a[i],a[i-1]))
return false;
return true;
}
public static void main(String[] args)
{

Scanner cin=new Scanner(System.in);
int n=cin.nextInt();
Integer[] temp= new Integer
;
for(int i=0;i<n;i++)
temp[i]=new Integer(cin.nextInt());
Comparable[] a=new Comparable
;

for(int i=0;i<n;i++)
{

a[i]=temp[i];
}
sort(a);
assert isSorted(a);
show(a);

}

}

插入排序（O(n) ~O（n*n））

左边有序，右边位置后移

public static void sort(Comparable[] a){
//a是升序排列
int N=a.length;
for(int i=1;i<N;i++)
// 将a[i]插入a[i-1],a[i-2],.... 之中
{
for(int j=i;j>0 && less(a[j],a[j-1]);j--)
exch(a,j,j-1);
}
}

希尔排序

任意间隔h的元素都是有序

public static void sort(Comparable[] a){
//a[]升序
int N=a.length;
int h=1;
while(h<N/3) h=3*h+1; //1,4,13,40...
while(h>=1){
// 将数组变成h有序
for(int i=h;i<N;i++){
//a[i]插入到a[i-h],a[i-2*h],a[i-3*h],....
for(int j=i; j>=h && less(a[j],a[j-h]);j-=h){
exch(a,j,j-h);
}
h=h/3;

}

}
}

归并排序

时间：NlgN

空间：N

import java.util.*;
import java.util.Comparator;

public class Solution {
private Solution(){} //初始化函数

private static Comparable[] aux; // 辅助数组
public static void merge(Comparable[] a,int lo,int mid,int hi){
//将a[lo..mid]和a[mid+1,..,hi]

int i=lo,j=mid+1;

for(int k=lo;k<=hi;k++) //将a[lo..hi]复制到aux[lo..hi]
aux[k]=a[k];

for(int k=lo;k<=hi;k++){
if(j>mid) a[k]=aux[j++];  //[j++]=[j]，然后j++
else if (j>hi) a[k]=a[i++];
else if (less(aux[j],aux[i])) a[k]=aux[j++];
else a[k]=aux[i++];
}
}

//自顶向下递归

public static void sort(Comparable[] a) //归并所需要排序的数组
{
aux=new Comparable[a.length]; //一次性分配空间
sort(a,0,a.length-1);
}

private static void sort(Comparable[] a,int lo,int hi){
//将数组a[lo...hi] 排序
if(hi<=lo) return;
int mid=lo+(hi-lo)/2;
sort(a,lo,mid); // 左边排序
sort(a,mid+1,hi); //右边排序
merge(a,lo,mid,hi);  // 归并结果
}

private static boolean less(Comparable v,Comparable w){
if(v.compareTo(w)<=0)
return true;
else
return false;
}

private static void exch(Comparable[] a, int i, int j){
Comparable t=a[i];a[i]=a[j];a[j]=t;
}
private static void show(Comparable[] a){
for(int i=0;i<a.length;i++)
System.out.println(a[i]+" ");
System.out.println(" ");
}
public static boolean isSorted(Comparable[] a){
//  测试元素是否有序
for(int i=1;i<a.length;i++)
if(less (a[i],a[i-1]))
return false;
return true;
}
public static void main(String[] args)
{

Scanner cin=new Scanner(System.in);
int n=cin.nextInt();
Integer[] temp= new Integer
;
for(int i=0;i<n;i++)
temp[i]=new Integer(cin.nextInt());
Comparable[] a=new Comparable
;

for(int i=0;i<n;i++)
{

a[i]=temp[i];
}
sort(a);
assert isSorted(a);
show(a);

}

}

非递归代码

自底向上的归并

public static void sort(Comparable[] a) //归并所需要排序的数组
{
//进行lgn次两两归并
int N=a.length;
aux=new Comparable
;
for(int sz=1;sz<N;sz=sz+sz) // sz子数组的大小
for(int lo=0;lo<N-sz;lo+=sz+sz){
merge(a,lo,lo+sz-1,Math.min(lo+sz+sz-1,N-1));
}

}

快速排序

时间复杂度：NlgN

空间复杂度：lgN

基本快速

import java.util.*;
import java.util.Comparator;

public class Solution {
private Solution(){} //初始化函数

public static void sort(Comparable[] a){
// StdRandom.shuffle(a);//打乱数组  // 保持随机性，或者随机选择数组
sort(a,0,a.length-1);

}

private static void sort(Comparable[] a,int lo,int hi){
if(lo<hi) return;
int j=partition(a,lo,hi); //切分函数
sort(a,lo,hi);//  将左半部分排序 a[low,j-1]
sort(a,j+1,hi); //将右半部分排序 a[j+1,hi]
}

//  切分函数，选择a[lo] 为切分值
private static int partition(Comparable[] a,int lo,int hi){
int i=lo,j=hi+1; //左右扫描指针
Comparable v=a[lo]; //切分元素
while(true){
//左右扫描，检查扫描是否结束，交换元素
while(less(a[++i],v)) if(i==hi) break;
while(less(v,a[--j])) if(j=lo) break;
if(i>=j) break;
exch(a,lo,j);
}
exch(a,lo,j); //将v=[j] 放入正确位置
return j;
}

private static boolean less(Comparable v,Comparable w){
if(v.compareTo(w)<=0)
return true;
else
return false;
}

private static void exch(Comparable[] a, int i, int j){
Comparable t=a[i];a[i]=a[j];a[j]=t;
}
private static void show(Comparable[] a){
for(int i=0;i<a.length;i++)
System.out.println(a[i]+" ");
System.out.println(" ");
}
public static boolean isSorted(Comparable[] a){
//  测试元素是否有序
for(int i=1;i<a.length;i++)
if(less (a[i],a[i-1]))
return false;
return true;
}
public static void main(String[] args)
{

Scanner cin=new Scanner(System.in);
int n=cin.nextInt();
Integer[] temp= new Integer
;
for(int i=0;i<n;i++)
temp[i]=new Integer(cin.nextInt());
Comparable[] a=new Comparable
;

for(int i=0;i<n;i++)
{

a[i]=temp[i];
}
sort(a);
assert isSorted(a);
show(a);

}

}

改进的快速排序

堆排序

建堆时间：o(n)

调整堆：O（lgn）

复杂度：O（nlgn）

import java.util.*;
import java.util.Comparator;

public class Solution {
private Solution(){} //初始化函数

public static void sort(Comparable[] a)
{
int N=a.length;
for(int k=N/2;k>=1;k--)
sink(a,k,N);// 下沉（由上而下的堆得有序化）// 构建了堆
while(N>1){
exch(a,1,N--);
sink(a,1,N);
}
}

private static void sink(Comparable[] a,int k, int N)
{
while(2*k<=N){
int j=2*k;
if(j<N && less(a,j,j+1))
j++;
if(!less(a,k,j))  break;
exch(a,k,j);
k=j;
}
}

private static boolean less(Comparable[] a,int i,int j){
return a[i-1].compareTo(a[j-1])<0;
}

private static boolean less(Comparable v,Comparable w){
if(v.compareTo(w)<=0)
return true;
else
return false;
}

private static void exch(Comparable[] a, int i, int j){
Comparable t=a[i];a[i]=a[j];a[j]=t;
}
private static void show(Comparable[] a){
for(int i=0;i<a.length;i++)
System.out.println(a[i]+" ");
System.out.println(" ");
}
public static boolean isSorted(Comparable[] a){
//  测试元素是否有序
for(int i=1;i<a.length;i++)
if(less (a[i],a[i-1]))
return false;
return true;
}
public static void main(String[] args)
{

Scanner cin=new Scanner(System.in);
int n=cin.nextInt();
Integer[] temp= new Integer
;
for(int i=0;i<n;i++)
temp[i]=new Integer(cin.nextInt());
Comparable[] a=new Comparable
;

for(int i=0;i<n;i++)
{

a[i]=temp[i];
}
sort(a);
assert isSorted(a);
show(a);

}

}