直接选择排序

首先找到数组中最小的元素，将其与第一个元素交换。随后在剩下的元素中找到最小的元素，与第二个元素交换。依次类推..

选择排序的内循环只是比较当前元素与目前已知的最小元素，交换元素的动作写在内循环外，每次交换都能确定一个元素的最终位置。

因此，交换的总次数为N，算法的时间效率取决于比较的次数。它有两个很鲜明的特点

1，运行时间和输入无关

为了找出最小的元素而扫描一遍数组并不能为下一遍扫描提供什么信息，使用选择排序的人可能会惊讶的发现一个已经有序的数组和一个随机排列的数组所用的排序时间竟然一样。

2，数据移动是最少的

每次交换都会改变两个数组元素的值，因此选择排序只用了N次交换。即交换次数和数组的大小是线性关系。其它算法则多是线性对数或平方关系。

JavaScript

function selectSort(ary) {
    var i, j, k, temp;
    var len = ary.length;
     
    for(i=0; i<len; i++) {
        k = i;
        // 找出最小的元素索引
        for(j=i+1; j<len; j++) {
            if(ary[k] > ary[j]) {
                k = j;
            }
        }
        temp = ary[i];
        ary[i] = ary[k];
        ary[k] = temp;
    }
     
    return ary;
}
// var ary = [5,4,3,2,1];
// console.log(selectSort(ary));

Java

public class Test {
     
    public static void selectSort(int[] ary) {
        int i, j, k, temp;
        int len = ary.length;
         
        for(i=0; i<len; i++) {
            k = i;
            for(j=i+1; j<len; j++) {
                if(ary[k] > ary[j]) {
                    k = j;
                }
            }
            temp = ary[i];
            ary[i] = ary[k];
            ary[k] = temp;
        }
         
    }
     
    public static void main(String[] args) {
        int[] ary = {5,4,3,2,1};
        Test.selectSort(ary);
        for(int it : ary) {
            System.out.println(it);
        }
 
    }   
}

void selectSort(int ary[], int len) {
    int i, j, k, temp;
    for(i=0; i<len; i++) {
        k = i;
        // 找出最小的元素索引 
        for(j=i+1; j<len; j++) {
            if(ary[k] > ary[j]) {
                k = j;  
            }
        }
        temp = ary[i];
        ary[i] = ary[k];
        ary[k] = temp;
    }
 
}
 
main() {
    int i;
    int ary[]  = {5,4,3,2,1};
    selectSort(ary, 5);
    for(i=0; i<5; i++) {
        printf("%d", ary[i]);
    }
     
}