（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();
}

}