看https://coding.imooc.com/class/71.html的课程并根据源代码https://github.com/shaojunying/Play-with-Algorithms的总结
选择排序
特点：
- 比较次数 O(n2)，比较次数与初始状态无关，为n(n-1)/2,赋值操作介于0和3(n-1)次之间(1次交换操作3次赋值).
- 交换次数比冒泡排序少,由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，选择排序比冒泡排序快。
原始排序
思路:每次循环找出剩余的最小的元素,放到最左边
public static void selectorSort(Comparable[] arr){
int n = arr.length;
for( int i = 0 ; i < n ; i ++ ){
// 寻找[i, n)区间里的最小值的索引
int minIndex = i;
for( int j = i + 1 ; j < n ; j ++ )
// 使用compareTo方法比较两个Comparable对象的大小
if( arr[j].compareTo( arr[minIndex] ) < 0 )
minIndex = j;
swap( arr , i , minIndex);
}
}
优化后的选择排序
思路:每次循环找出剩余最小元素的同事找出最大元素分别放在两边,将会减少一半的循环
public static void selectotSort2(Comparable[] arr){
int left = 0, right = arr.length - 1;
while(left < right){
int minIndex = left;
int maxIndex = right;
// 在每一轮查找时, 要保证arr[minIndex] <= arr[maxIndex]
if(arr[minIndex].compareTo(arr[maxIndex]) > 0)
swap(arr, minIndex, maxIndex);
for(int i = left + 1 ; i < right; i ++)
if(arr[i].compareTo(arr[minIndex]) < 0)
minIndex = i;
else if(arr[i].compareTo(arr[maxIndex]) > 0)
maxIndex = i;
swap(arr, left, minIndex);
swap(arr, right, maxIndex);
left ++;
right --;
}
}
插入排序
注：写法1和写法2基本类似，写法3则先取出目标的元素，将前面的需要后移的后移，之后再将目标元素赋给目标位置，避免了排序中发生较多的交换操作，故较1，2耗时少
特点:
- 最好情况下,只需要n-1次比较即可
- 最坏情况下,需要n(n-1)/2次比较,赋值操作需要比较次数减去n-1次,因为n-1次循环中,每次循环最后一次比较不用赋值
- 量级小于千,或一直输入元素大致按照顺序排列,插入排序是一个不错的选择
public static void insertSort(Comparable[] arr){
int n = arr.length;
for (int i = 0; i < n; i++) {
// 寻找元素arr[i]合适的插入位置
// 写法1
// for( int j = i ; j > 0 ; j -- )
// if( arr[j].compareTo( arr[j-1] ) < 0 )
// swap( arr, j , j-1 );
// else
// break;
// 写法2
// for( int j = i; j > 0 && arr[j].compareTo(arr[j-1]) < 0 ; j--)
// swap(arr, j, j-1);
// 写法3
Comparable e = arr[i];
int j = i;
for( ; j > 0 && arr[j-1].compareTo(e) > 0 ; j--)
arr[j] = arr[j-1];
arr[j] = e;
}
}
冒泡排序
原始的
一直遍历，每次遍历都比较当前元素和他的前一个元素，顺序不符合就交换，知道有一次循环没有进行交换就停止循环
注意:
public static void bubbleSort(Comparable[] arr){
int n = arr.length;
boolean swapped = false;
do{
swapped = false;
for( int i = 1 ; i < n ; i ++ )
if( arr[i-1].compareTo(arr[i]) > 0 ){
swap( arr , i-1 , i );
swapped = true;
}
// 优化, 每一趟Bubble Sort都将最大的元素放在了最后的位置
// 所以下一次排序, 最后的元素可以不再考虑
n --;
}while(swapped);
}
改进的
每次循环之后都记录最后一次交换的位置，从而能减少循环次数
public static void bubbleSort(Comparable[] arr){
int n = arr.length;
int newn; // 使用newn进行优化
do{
newn = 0;
for( int i = 1 ; i < n ; i ++ )
if( arr[i-1].compareTo(arr[i]) > 0 ){
swap( arr , i-1 , i );
// 记录最后一次的交换位置,在此之后的元素在下一轮扫描中均不考虑
newn = i;
}
n = newn;
}while(newn > 0);
}
希尔排序
public static void shellSort(Comparable[] arr){
int n = arr.length;
// 计算 increment sequence: 1, 4, 13, 40, 121, 364, 1093...
int h = 1;
while (h < n/3) h = 3*h + 1;
while (h >= 1) {
// h-sort the array
for (int i = h; i < n; i++) {
// 对 arr[i], arr[i-h], arr[i-2*h], arr[i-3*h]... 使用插入排序
Comparable e = arr[i];
int j = i;
for ( ; j >= h && e.compareTo(arr[j-h]) < 0 ; j -= h)
arr[j] = arr[j-h];
arr[j] = e;
}
h /= 3;
}
总结
- 对于上面的插入排序的方法1，2由于需要进行过多的交换操作，因此排序时间要大于选择排序。然鹅
插入排序的方法3跟方法1，2比较避免了太多的交换，跟选择排序相比则可以更早的结束循环，因此时间较短。 - 对于一个近乎有序的数组来说，插入排序的性能要远远优于选择排序，甚至优于nlogn的算法。例如对系统的日志进行排序的时候，插入排序的性能会更好。在
这里应该附上一个所有算法的全部时间对照
