選擇排序是排序方法中最簡單效率最低的算法

該方法會遍歷（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]]

第二行是排序後。

明天過來寫插入排序

排序算法——選擇排序