内部排序算法系列---直接选择排序
常见的内部排序分类：
我们来看下直接选择排序，其实思路很简单，就是从第一个数字开始依次跟后面的数字进行比对来交互位置，每一趟可以找出一个最小的；但是需要经过n-1趟比较。直接上程序吧：
import java.util.Arrays;
/**
* @author stefanie zhao
* @date 2014-9-25 下午04:09:48
*/
public class SelectSort {
public static void selectSort(DataWrap[] data){
System.out.println("begin sort......");
int arrayLength = data.length;
for(int i = 0 ; i <= arrayLength - 1 ; i++){
for(int j = i + 1 ; j < arrayLength ; j++){
if(data[i].compareTo(data[j]) > 0){
DataWrap tmp = data[i];
data[i] = data[j];
data[j] = tmp;
}
}
System.out.println(Arrays.toString(data));
}
}
public static void main(String[] args) {
DataWrap[] data = {new DataWrap(23, ""),
new DataWrap(13, ""),
new DataWrap(43, ""),
new DataWrap(9, ""),
new DataWrap(3, ""),
new DataWrap(34, "")
};
System.out.println("before sort: \n"+Arrays.toString(data));
selectSort(data);
System.out.println("after sort: \n"+Arrays.toString(data));
}
}
class DataWrap implements Comparable<DataWrap>{
int data;
String flag;
public DataWrap(int data, String flag) {
this.data = data;
this.flag = flag;
}
@Override
public String toString() {
return data + flag;
}
@Override
public int compareTo(DataWrap o) {
return this.data > o.data ? 1 : (this.data == o.data ? 0 : -1);
}
}
运行结果如下：
before sort:
[23, 13, 43, 9, 3, 34]
begin sort......
[3, 23, 43, 13, 9, 34]
[3, 9, 43, 23, 13, 34]
[3, 9, 13, 43, 23, 34]
[3, 9, 13, 23, 43, 34]
[3, 9, 13, 23, 34, 43]
[3, 9, 13, 23, 34, 43]
after sort:
[3, 9, 13, 23, 34, 43]
上面的算法有一个很大的问题，每趟的比较过程中，程序一旦发现某个数比第一位的数据小，就交换他们。既然直接选择排序需要n-1次趟比较，那么每趟比较只需要一次交换就可以了，而以上的算法有可能导致一趟有多次比较，浪费了效率，所以我们改进下算法：
//改进版
public static void selectSortPro(DataWrap[] data){
System.out.println("begin sort......");
int arrayLength = data.length;
for(int i = 0 ; i <= arrayLength - 1 ; i++){
//保留本趟比较中最小值的索引
int minIndex = i;
for(int j = i + 1 ; j < arrayLength ; j++){
if(data[minIndex].compareTo(data[j]) > 0){
minIndex = j;
}
}
if(minIndex != i){
DataWrap tmp = data[i];
data[i] = data[minIndex];
data[minIndex] = tmp;
}
System.out.println(Arrays.toString(data));
}
}
运行结果如下：
before sort:
[23, 13, 43, 9, 3, 34]
begin sort......
[3, 13, 43, 9, 23, 34]
[3, 9, 43, 13, 23, 34]
[3, 9, 13, 43, 23, 34]
[3, 9, 13, 23, 43, 34]
[3, 9, 13, 23, 34, 43]
[3, 9, 13, 23, 34, 43]
after sort:
[3, 9, 13, 23, 34, 43]
以上改进，我们只需要找出每趟一个最小值的索引(minIndex)和当前趟的索引 (i) 进行比较交换就可以了。
对于直接选择排序算法而言，如果有n个数据，数据交换的次数最多有n-1次，但是程序比较次数比较多，总体来说，时间效率为O(n^2)，但空间效率为O(1)。