各排序算法核心

1.插入排序

//第一个默认有序
for(int i = 1; i < a.length; i++){
	//从后往前
	for(int j = i-1; j >= 0; j--){
		if(a[j]>a[i]){
			exch(a, i, j);
			i--;
		}
	}
}

2.选择排序

for (int i = 0; i < a.length; i++){
	int min = i;
	//剩下的里面找最小的
	for (int j = i + 1; j < N; j++)
		if (a[j]<a[min])
			min = j;
	//放前面
	exch(a, i, min);
}

3.冒泡排序

//每次确定一个最大的,直到倒数第二小的
for(int i = a.length-1; i > 0; i--){
	for(int j = 0; j < i; j++){
		if(a[j] > a[j+1])
			exch(a, j, j+1);
	}
}

插入排序就是打牌的时候理牌的习惯，选择排序思想最白痴，每次找个最小的，冒泡排序实现过程像插入排序，因为exch，从外部看更像选择，每次确定一个最大的。

4.希尔排序

希尔排序就是插入排序的改进版，先把数组按间隔分，然后用插入排序，在减小间隔继续插入排序直到间隔为1。

5.归并排序

public static Comparable[] aux;
public static void sort(Comparable[] a){
	aux = new Comparable[a.length];
	sort(a, 0, a.length - 1);
}
public static void sort(Comparable[] a, int l, int h){
	if (h <= l)
		return;
	int m = l + (h - l)/2;
	sort(a, l, m);
	sort(a, m+1, h);
	merge(a, l, m, h);
}
public static void merge(Comparable[] a, int l, int m, int h){
	int i = l;
	int j = m + 1;
	for (int k = l; k < a.length; k++)
		aux[k] = a[k];
	for (int k = l; k <= h; k++){
		if (i > m)
			a[k] = aux[j++];
		else if (j > h)
			a[k] = aux[i++];
		else if (less(aux[i], aux[j]))
			a[k] = aux[i++];
		else 
			a[k] = aux[j++];
	}
}

6.快速排序

public static void sort(Comparable[] a){
	//此处应该有打乱
	sort(a, 0, a.length -1);
}
private static void sort(Comparable[] a, int l, int h){
	if (h <= l)
		return;
	int j = partition(a, l, h);
	sort(a, l, j-1);
	sort(a, j+1, h);
}
private static int partition(Comparable[] a, int l, int h){
	int i = l, j = h + 1;
	Comparable v = a[l];
	while(true){
		while (less(a[++i], v))
			if (i == h) break;
		while (less(v, a[--j]))
			if (j == l) break;
		if (i >= j)
			break;
		exch(a, i, j);
	}
	exch(a, l, j);
	return j;
}

    
    

     
     
public static void sort(Comparable[] a){
	aux = new Comparable[a.length];
	sort(a, 0, a.length - 1);
}