一 插入排序法:
说明: 每次将一个待排序的记录,按其关键字大小插入到前面已经排好序的子文件中的适当位置,直到全部记录插入完成为止。
- public class InsertSorter > extends Sorter {
- /**
- * from 起始位置
- * len 从起始位置开始 需要比较的次数
- */
- public void sort(E[] array, int from, int len) {
- E tmp=null;
- for(int i=from+1;i
- tmp=array[i];
- int j=i;
- for(;j>from;j--){
- if(tmp.compareTo(array[j-1])<0){
- array[j]=array[j-1];
- }
- else break;
- }
- array[j]=tmp;
- }
- }
- }
public class InsertSorter > extends Sorter { /** * from 起始位置 * len 从起始位置开始 需要比较的次数 */ public void sort(E[] array, int from, int len) { E tmp=null; for(int i=from+1;i from;j--){ if(tmp.compareTo(array[j-1])<0){ array[j]=array[j-1]; } else break; } array[j]=tmp; } } }
二 冒泡排序法:
说明: 算法思想是每次从数组末端开始比较相邻两元素,把第i小的冒泡到数组的第i个位置。i从0一直到N-1从而完成排序。(当然也可以从数组开始端开始比较相邻两元素,把第i大的冒泡到数组的第N-i个位置。i从0一直到N-1从而完成排序。)
- public class BubbleSorter > extends Sorter {
- private static boolean DWON=true;
- public final void bubble_down(E[] array, int from, int len)
- {
- for(int i=from;i
- {
- for(int j=from+len-1;j>i;j--)
- {
- if(array[j].compareTo(array[j-1])<0)
- {
- swap(array,j-1,j);
- }
- }
- }
- }
- public final void bubble_up(E[] array, int from, int len)
- {
- for(int i=from+len-1;i>=from;i--)
- {
- for(int j=from;j
- {
- if(array[j].compareTo(array[j+1])>0)
- {
- swap(array,j,j+1);
- }
- }
- }
- }
- @Override
- public void sort(E[] array, int from, int len) {
- if(DWON)
- {
- bubble_down(array,from,len);
- }
- else
- {
- bubble_up(array,from,len);
- }
- }
- }
public class BubbleSorter > extends Sorter { private static boolean DWON=true; public final void bubble_down(E[] array, int from, int len) { for(int i=from;i i;j--) { if(array[j].compareTo(array[j-1])<0) { swap(array,j-1,j); } } } } public final void bubble_up(E[] array, int from, int len) { for(int i=from+len-1;i>=from;i--) { for(int j=from;j 0) { swap(array,j,j+1); } } } } @Override public void sort(E[] array, int from, int len) { if(DWON) { bubble_down(array,from,len); } else { bubble_up(array,from,len); } } }
三 选择排序法:
说明: 选择排序相对于冒泡来说,它不是每次发现逆序都交换,而是在找到全局第i小的时候记下该元素位置,最后跟第i个元素交换,从而保证数组最终的有序。相对与插入排序来说,选择排序每次选出的都是全局第i小的,不会调整前i个元素了。
- public class SelectSorter > extends Sorter {
- @Override
- public void sort(E[] array, int from, int len) {
- for(int i=0;i
- int smallest=i;
- int j=i+from;
- for(;j
- if(array[j].compareTo(array[smallest])<0)
- smallest=j;
- }
- swap(array,i,smallest);
- }
- }
- }
四 选择排序法:
说明: 该方法只是通过遍历集合记录最小(大)元素的位置,一次遍历完后,再进行交换位置操作,类似冒泡,但在比较过程中,不进行交换操作,只记录元素位置。一次遍历只进行一次交换操作。这个对与交换次序比较费时的元素比较适合。这种排序法比冒泡法要城府要深的多,我先记住极端数据,待遍历数据完了之后,我再处理,不像冒泡法那样只要比自己极端一点的就要处理,选择法只处理本身范围内的最极端数据.
public class SelectionSort implements SortUtil.Sort {
/*
* (non-Javadoc)
*
* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/
public void sort(int[] data) {
int temp;
for (int i = 0; i < data.length; i++) {
int lowIndex = i;
for (int j = data.length - 1; j > i; j--) {
if (data[j] < data[lowIndex]) {
lowIndex = j;
}
}
SortUtil.swap(data,i,lowIndex);
}
}
}
五 Shell排序:
说明: 它是对插入排序的一种改进,是考虑将集合元素按照一定的基数划分成组去排序,让每一组在局部范围内先排成基本有序,最后在进行一次所有元素的插入排序。
public void sort(int[] data) {
for(int i=data.length/2; i〉2; i/=2){
for(int j=0; j〈i; j++) {
insertSort(data,j,i);
}
}
insertSort(data,0,1);
}
private void insertSort(int[] data, int start, int inc) {
int temp;
for(int i=start+inc; i〈data.length; i+=inc){
for(int j=i; (j〉=inc)&&(data[j]〈data[j-inc]); j-=inc){
temp=data[j];
data[j]=data[j-inc]
data[j-inc]=temp;
}
}
}