排序算法——选择排序

选择排序是排序方法中最简单效率最低的算法

该方法会遍历（N²）/2：每次抽一位最小数或者最大数放在数组头部。再遍历抽取剩下的数组最小数

如下所示：

原数组：9，8，7，6，5，4，3，2，1

第一轮：1，8，7，6，5，4，3，2，9

第二轮：1，2，7，6，5，4，3，8，9
第三轮：1，2，3，6，5，4，7，8，9
第四轮：1，2，3，4，5，6，7，8，9
第五轮：1，2，3，4，5，6，7，8，9
第六轮：1，2，3，4，5，6，7，8，9
第七轮：1，2，3，4，5，6，7，8，9
第八轮：1，2，3，4，5，6，7，8，9
第九轮：1，2，3，4，5，6，7，8，9

如上图所示这个算法每次都会在红色数字右边选择最小的数字，然后放入红色的位置中去

效率是（N²）/2。非常简单的效率低的算法。

代码如下（我写的多了点，以便于后面研究其他算法。java就这么麻烦）：

/**
 * 排序实验的参数
 * @author DHH
 *
 */
public class DATA implements Comparable  {
    private int i=0;
    
    DATA(int i){
        this.i=i;
    }
    
    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    @Override
    public int compareTo(Object o) {
    
        return this.i-((DATA)o).getI();
    }

    @Override
    public String toString() {
        return "DATA [i=" + i + "]";
    }
    
}

/**
 * 用来继承的父类对象
 * @author DHH
 *
 */
public class Example  {
    /**
     * 为一个数组排序
     * @param a
     */
    public void sort(Comparable[] a){
        
    }
    /**
     * 比较两个数组中的两个值
     * @param a
     * @param i
     * @param j
     * @return
     */
    public int compare(Comparable[] a,int i,int j){
        Comparable m=a[i];
        Comparable n=a[j];
        return m.compareTo(n);
    }
    /**
     * @function 交换数组中的两个下标的位置
     * @param a
     * @param i
     * @param j
     */
    public static void exch(Comparable[] a,int i,int j){
        Comparable m=a[i];
        a[i]=a[j];
        a[j]=m;
    }
}

/**
 * 选择排序
 * @author DHH
 *
 */
public class Select extends Example {
    /**
     * 选择排序的排序代码
     */
    public void sort(Comparable[] a){
        int k;
        for(int i=0;i<a.length;i++){
            k=i;
            for(int j=i;j<a.length;j++){
                if(a[k].compareTo(a[j])<=0){
                    k=j;
                }
            }
            exch(a, i, k);
        }
    }
    
    /**
     * 测试方法
     * @param args
     */
    public static void main(String[] args) {
        DATA[] dataArray=new DATA[10];
        dataArray[0]=new DATA(16);
        dataArray[1]=new DATA(6);
        dataArray[2]=new DATA(15);
        dataArray[3]=new DATA(8);
        dataArray[4]=new DATA(11);
        dataArray[5]=new DATA(23);
        dataArray[6]=new DATA(75);
        dataArray[7]=new DATA(4);
        dataArray[8]=new DATA(11);
        dataArray[9]=new DATA(60);
        System.out.println(Arrays.toString(dataArray));
        Select select=new Select();
        select.sort(dataArray);
        System.out.println(Arrays.toString(dataArray));
    }

}

以上代码输出为两行dataArray。

第一行为：[DATA [i=16], DATA [i=6], DATA [i=15], DATA [i=8], DATA [i=11], DATA [i=23], DATA [i=75], DATA [i=4], DATA [i=11], DATA [i=60]]

第二行为：[DATA [i=75], DATA [i=60], DATA [i=23], DATA [i=16], DATA [i=15], DATA [i=11], DATA [i=11], DATA [i=8], DATA [i=6], DATA [i=4]]

第二行是排序后。

明天过来写插入排序