（1）排序算法——选择排序

排序算法有很多，包括选择排序、插入排序、冒泡排序、合并排序、快速排序、堆排序等，这些算法各有优点。首先，我们先看下不同时间复杂度的区别：

选择排序算法是在列表中找到最小（大）数，并将其放在表头（尾），然后在剩下的数中找到最小（大）数，放到第一个数之后（最后一个数之前），这样一直做下去，直到列表中只剩一个数为止。选择排序算法的时间复杂度为O(n*n)(n为数据量)。

import java.util.ArrayList;
import java.util.List;

public class SelectionSort {

    /**对整型数组进行选择排序**/
    public static void sort(int[] list){
        int listLen=list.length;
        for(int i=0;i<listLen;i++){
            int currentMin=list[i];
            int currentMinIndex=i;
            for(int j=i+1;j<listLen;j++){
                if(currentMin>list[j]){
                    currentMin=list[j];
                    currentMinIndex=j;
                }
            }
            if(currentMinIndex!=i){
                list[currentMinIndex]=list[i];
                list[i]=currentMin;
            }
        }
    }

    /**对浮点型数组进行选择排序**/
    public static void sort(double[] list){
        for(int i=0;i<list.length-1;i++){
            double currentMin=list[i];
            int currentMinIndex=i;
            for(int j=i+1;j<list.length;j++){
                if(currentMin>list[j]){
                    currentMin=list[j];
                    currentMinIndex=j;
                }
            }
            if(currentMinIndex!=i){
                list[currentMinIndex]=list[i];
                list[i]=currentMin;
            }
        }
    }

    /**对Comparable基本Number包装类型数组进行选择排序
     * 通过先找出最小数，将最小数放在前面来实现**/
    public static void sort(Comparable[] list){
        Comparable currentMin;
        int currentMinIndex;
        int listLen=list.length;
        for(int i=0;i<listLen-1;i++){
            currentMin=list[i];
            currentMinIndex=i;
            for(int j=i+1;j<listLen;j++){
                //如果currenMin大于list[j]
                if(currentMin.compareTo(list[j])>0){
                    currentMin=list[j];
                    currentMinIndex=j;
                }
            }
            if(currentMinIndex!=i){
                list[currentMinIndex]=list[i];
                list[i]=currentMin;
            }
        }
    }

    /**对Comparable基本Number包装类型数组进行选择排序
     * 利用泛型方法，通过先找出最大数来实现，将最大数放在后面**/
    public static <E extends Comparable<E>> void selectionSort(E[] list) {
        int listLen=list.length;
        for (int i = listLen - 1; i >= 1; i--) {
          // Find the maximum in the list[0..i]
          E currentMax = list[0];
          int currentMaxIndex = 0;
          for (int j = 1; j <= i; j++) {
            //如果currenMax小于list[j]
            if (currentMax.compareTo(list[j]) < 0) {
              currentMax = list[j];
              currentMaxIndex = j;
            }
          }
          // Swap list[i] with list[currentMaxIndex] if necessary;
          if (currentMaxIndex != i) {
            list[currentMaxIndex] = list[i];
            list[i] = currentMax;
          }
        }
    }  

    /**对List进行选择排序**/
    public static <E extends Comparable<E>> void selectionSort(List<E> list) {
        int listLen=list.size();
        for (int i = listLen - 1; i >= 1; i--) {
          E currentMax = list.get(i);
          int currentMaxIndex = 0;
          for (int j = 1; j <= i; j++) {
            //如果currenMax小于list.get(j)
            if (currentMax.compareTo(list.get(j)) < 0) {
              currentMax = list.get(j);
              currentMaxIndex = j;
            }
          }
          if (currentMaxIndex != i) {
            list.set(currentMaxIndex,list.get(i));
            list.set(i, currentMax);
          }
        }
    }  

    /**对二维数组进行选择排序**/
    public static void twoDimensionArraySort(int m[][]) {
        for (int i = 0; i < m.length; i++) {
            double currentMin = m[i][0];
            int currentMinIndex = i;
            for (int j = i; j < m.length; j++) {
                if (currentMin > m[j][0] // primary sort
                    || (currentMin == m[j][0] 
                        && m[currentMinIndex][1] > m[j][1])) // secondary sort                                                                                 
                    {
                        currentMin = m[j][0];
                        currentMinIndex = j;
                    }
              }
            // Swap list[i] with list[currentMinIndex] if necessary;
            if (currentMinIndex != i) {
                int temp0 = m[currentMinIndex][0];
                int temp1 = m[currentMinIndex][1];
                m[currentMinIndex][0] = m[i][0];
                m[currentMinIndex][1] = m[i][1];
                m[i][0] = temp0;
                m[i][1] = temp1;
            }
        }
    }

    /**主函数测试**/
    public static void main(String[] args){
        Integer[] array={1,45,2,5,546,34};
        List<Integer> list=new ArrayList();
        for(int i: array){
            list.add(i);
        }
        selectionSort(list);
        System.out.println(list);
        selectionSort(array);
        print(array);
    }

    /**打印数组**/
    public static void print(Comparable[] list){
        for(int i=0;i<list.length;i++){
            System.out.print(list[i]+" ");
        }
        System.out.println();
    }

}