排序

JAVA实现：

选择排序，插入排序，冒泡排序，希尔排序，归并排序，快速排序，堆排序

public class Sort {

/**
* 选择排序
* @param arr
*/
public static void chooseSort(Comparable[] arr){
for(int i=0; i<arr.length;i++){
int min = i;
for(int j=i+1;j<arr.length;j++){
if(less(arr[i],arr[j])){
min = j;
}
}

if(min != i){
exch(arr,i,min);
}
}
}

/**
* 插入排序
* @param arr
*/
public static void insertSort(Comparable[] arr){
for(int i=1; i<=arr.length-1;i++){
for(int j=i; j>0 && less(arr[j-1],arr[j]);j--){
exch(arr, j-1, j);
}
}
}

/**
* 冒泡排序
* @param arr
*/
public static void BubbleSort(Comparable[] arr){
boolean isexch = false;
for(int i=0;i<arr.length-1;i++){
isexch = false;
for(int j=arr.length-1;j>=1+i;j--){
if(less(arr[j-1],arr[j])){
exch(arr,j-1,j);
isexch = true;
}
}

if(!isexch){
break;
}
}
}

/**
* 希尔排序
* 保证每次循环后相隔h个数的局部排序为有序
* @param arr
*/
public static void shellSort(Comparable[] arr){
int N = arr.length;
int h = 1;
while(N/3 > h) h = 3*h+1;
while(h >= 1){
for(int i=h;i<N;i++){
for(int j=i; j >= h && less(arr[j-h],arr[j]); j -= h){
exch(arr, j, j-h);
}
}

h = h/3;
}
}


/**
* 归并排序
* @param arr 数组
* @param low 开始索引
* @param high 结束索引
*/
public static void mergeSort(Comparable[] arr, int low, int high){
int mid = (high + low)/2;

if(low < high){
mergeSort(arr, low, mid);
mergeSort(arr, mid + 1, high);
merge(arr, low, mid, high);
}

}

private static void merge(Comparable[] arr, int low, int mid, int high){
Comparable[] temp = new Comparable[high - low + 1]; //每次递归都会创建该对象，开销大
int i = low;
    int j = mid + 1;
    
    for(int k=0; k<temp.length;k++){
    if(i > mid){
    temp[k] = arr[j++];
    }else if(j > high){
    temp[k] = arr[i++];
    }
    else if(less(arr[i],arr[j])){
    temp[k] = arr[j++];
    }else{
    temp[k] = arr[i++];
    }
    }
    
    for(int k=0;k<temp.length;k++){
    arr[low + k] = temp[k];
    }
    
}


/**
* 快速排序
* @param arr
* @param low
* @param high
*/
public static void quickSort(Comparable[] arr, int low, int high){
if(low > high) 
return;

int v = low;
int i = low;
int j = high+1;

while(i < j){
while(less(arr[--j], arr[v])){  
                if(j <= i) break; 
            }
while(less(arr[v],arr[++i])) {  
                if(i >= j) break; 
            }
if(i < j){
exch(arr, i, j);
}
}

exch(arr, v, j);
quickSort(arr, low, j-1);
quickSort(arr, j+1, high);

}

/**
* 堆排序
* @param arr
*/
public static void heapSort(Comparable[] arr){
    int N = arr.length;
    
    for(int k = N/2 ; k >= 1; k--){
        sink(arr, k, N);
    }
    while(N > 1){
        exch(arr, 0, N---1);
        sink(arr, 1, N);
    }
}

/**
     * 下沉
     */
    private static void sink(Comparable[] arr, int k, int N){
        while(2*k <= N){
            int j = 2*k;
            if(j < N && less(arr[j-1], arr[j])) 
                j++;
            if(!less(arr[k-1], arr[j-1])) 
                break;
            exch(arr, k-1, j-1);
            k = j;
        }
    }
    
    /**
     * 上浮
     */
    private static void swim(){
        
    }

private static void exch(Comparable[] arr, int a,int b) {
Comparable temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}


private static boolean less(Comparable c1, Comparable c2) {
return c1.compareTo(c2) > 0;
}


public static void main(String[] args) {
Integer[] arr = new Integer[]{22,1,5,8,24,23,25,6,23,27,10,24,11,4,9};
//Integer[] arr = new Integer[]{5,4,3,7,6};
//Sort.chooseSort(arr);
//Sort.insertSort(arr);
//Sort.BubbleSort(arr);
//Sort.shellSort(arr);
//Sort.mergeSort(arr, 0, arr.length-1);
//Sort.quickSort(arr, 0, arr.length-1);
Sort.heapSort(arr);

String s = "";
for(int a : arr){
s += a + ",";
}
System.out.println(s.substring(0,s.length()-1));

}
}