JAVA简单选择排序算法原理及实现

简单选择排序：（选出最小值，放在第一位，然后第一位向后推移，如此循环）第一位与后面每一个逐个比较，每次都使最小的置顶，第一位向后推进（即刚选定的第一位是最小值，不再参与比较，比较次数减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 <= 1）
　　return;
　　int i, j, value, minpos, len = data.length;
　　int outer = len - 1, tmp;
　　for （i = 0; i < outer; i++） {
　　value = data[i];
　　minpos = -1;
　　for （j = i + 1; j < len; j++） {
　　if （data[j] < value） {
　　minpos = j;
　　value = data[j];
　　}
　　}
　　if （minpos != -1） {
　　tmp = data[i];
　　data[i] = value;
　　data[minpos] = tmp;
　　}
　　//            for （int k = 0; k < len; k++） {
　　//                system.out.print（data[k] + " , "）；
　　//            }
　　//            system.out.println（）；
　　}
　　}
　　public static void main（string[] args） {
　　int[] coll = {
　　37, 40, 38, 42, 461, 5,  7, 9, 12
　　};
　　selectionsort（coll）；
　　for （int i = 0; i < coll.length; i++） {
　　system.out.print（coll[i] + " , "）；
　　}
　　}

　　树选择排序（tree selection sort）
　　树选择排序算法相对于简单选择排序来说是典型的以空间换时间的算法。其思想是对待排序的 n 个元素 , 构造出相对较小的 （n+1）/2个数，然后再构造出相对较小的[n+1]/4个数，直到只有一个元素为止。构造成一个完全二叉树。
　　排序的时候，那个元素就是最小的，取出该最小元素，将该元素替换为"最大值",再调整完全二叉树。
下面是树形选择排序的一个java实现版：

　　public static void treeselectionsort（int[] data） {
　　if （data == null || data.length <= 1）
　　return;
　　int len = data.length , low = 0 , i , j;
　　// add auxiliary space
　　int[] tmp = new int[2*len -1];
　　int tsize = tmp.length;
　　//construct a tree
　　for（i =len-1 , j=tmp.length-1;i >=0 ;i--,j--）{
　　tmp[j]=data[i];
　　}
　　for（i = tsize -1 ; i > 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;
　　}
　　}

　　则实现递归的构造新集合中的最小值。