内部排序算法系列---直接选择排序

常见的内部排序分类：

我们来看下直接选择排序，其实思路很简单，就是从第一个数字开始依次跟后面的数字进行比对来交互位置，每一趟可以找出一个最小的；但是需要经过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)。

来源：oschina

链接：https://my.oschina.net/u/723271/blog/318636