简单选择排序：（选出最小值，放在第一位，然后第一位向后推移，如此循环）第一位与后面每一个逐个比较，每次都使最小的置顶，第一位向后推进（即刚选定的第一位是最小值，不再参与比较，比较次数减1）
复杂度： 所需进行记录移动的操作次数较少 0--3(n-1) ，无论记录的初始排列如何，所需的关键字间的比较次数相同，均为n(n-1)/2，总的时间复杂度为O(n2)；
空间复杂度 O(1)
算法改进：每次对比，都是为了将最小的值放到第一位，所以可以一比到底，找出最小值，直接放到第一位，省去无意义的调换移动操作。也可以换一个方向，最后一位与前面每一个比较，每次使最大值沉底，最后一位向前推进。
JAVA源代码：
public static void selectSort(Date[] days) {
int min;
Date temp;
for (int i = 0; i < days.length; i++) {
min = i;
for (int j = min + 1; j < days.length; j++) {
if (days[min].compare(days[j]) > 0) {
min = j;
}
}
if (min != i) {
temp = days[i];
days[i] = days[min];
days[min] = temp;
}
}
}
class Date {
int year, month, day;
Date(int y, int m, int d) {
year = y;
month = m;
day = d;
}
public int compare(Date date) {
return year > date.year ? 1 : year < date.year ? -1
: month > date.month ? 1 : month < date.month ? -1
: day > date.day ? 1 : day < date.day ? -1 : 0;
}
public void print() {
System.out.println(year + " " + month + " " + day);
}
}
简单选择排序（Simple Selection Sort）：
简单选择排序类似于冒泡排序（Bubble Sort） ,每次都会在剩下的元素集合中选择出一个最值出来填充到当前位置。唯一的区别是，冒泡排序在每次发现比当前值小于（或大于）时，都会交换元素的位置， 而 简单选择排序是选择剩余元素中的最值和当前位置交换数据。
比如对于元素集合R={37, 40, 38, 42, 461, 5, 7, 9, 12}
在第一趟排序中：37直接和5交换， 形成新的序列 R1={5,40,38,42,461,37,7,9,12}
在第二趟排序中：40直接和7交换， 形成新的序列 R2={5,7,38,42,461,37,40,9,12}
以此类推，直到最后一个元素（注意：在第二趟排序中，38比42小，但是他们并没有交换数据）。
以下是简单选择排序的一个Java实现版本：
public static void selectionSort（int[] data） {
if （data == null || data.length 0 ; i-=2）{
tmp[（i-1）/2] = tmp[i] > tmp[i-1]? tmp[i-1]:tmp[i];
}
//end
//remove the minimum node.
while（low < len）{
data[low++] = tmp[0];
for（j=tSize-1;tmp[j]!=tmp[0];j--）；
tmp[j] = Integer.MAX_VALUE;
while（j > 0）{
if（j%2 == 0）{ //如果是右节点
tmp[（j-1）/2] = tmp[j] > tmp[j-1]?tmp[j-1]:tmp[j];
j = （j-1）/2;
}else{ //如果是左节点
tmp[j/2]=tmp[j] > tmp[j+1]? tmp[j+1]:tmp[j];
j = j/2;
}
}
}
}
在构造完全二叉树的时候对 N 个元素的集合， 需要 2*N -1 个辅助空间。
代码：
while（j > 0）{
if（j%2 == 0）{ //如果是右节点
tmp[（j-1）/2] = tmp[j] > tmp[j-1]?tmp[j-1]:tmp[j];
j = （j-1）/2;
}else{ //如果是左节点
tmp[j/2]=tmp[j] > tmp[j+1]? tmp[j+1]:tmp[j];
j = j/2;
}
}
则实现递归的构造新集合中的最小值。