选择排序

1.选择排序的基本介绍

选择排序也属于内部排序法，是从需排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。

2.选择排序的思想

选择排序（Select Sorting）也是一种简单的排序方法，它的基本思想是：

• 第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换
• 第二次从arr[1]~arr[n-1]中选取最小值，与arr[1]交换
• 第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换
• 第i次从arr[i-1]~arr[n-1]中选取最小值，与arr[i-1]交换

3.选择排序思路分析

原始的数组 ： 101, 34, 119, 1
第一轮排序 :   1, 34, 119, 101
第二轮排序 :   1, 34, 119, 101
第三轮排序 :   1, 34, 101, 119

说明：
1. 选择排序一共有 数组大小 - 1 轮排序
2. 每1轮排序，又是一个循环, 循环的规则(代码)
2.1先假定当前这个数是最小数
2.2 然后和后面的每个数进行比较，如果发现有比当前数更小的数，就重新确定最小数，并得到下标
2.3 当遍历到数组的最后时，就得到本轮最小数和下标
2.4 交换 [代码中再继续说 ]

4.选择排序的代码实现

package sort.demo;
import java.util.Arrays;

public class SelectSort {
 public static void main(String[] args) {
     int[] arr = {108, 32, 120, 10};
     selectSort(arr);
 }

 //选择排序
 public static void selectSort(int[] arr) {
     //原始的数组：108，32，120，10
     //第一轮排序结果：10，32，120，108

     int minIndex = 0;
     int min = arr[0];
     for (int j = 0 + 1; j < arr.length; j++) {
         if (min > arr[j]) { //说看假定的最小值，并不是最小
             min = arr[j];//重置min
             minIndex = j;//重置minIndex
         }
     }
     //将最小值放在arr[0]，即交换位置
     if (minIndex != 0) {
         arr[minIndex] = arr[0];
         arr[0] = min;
     }
     //输出结果:第一轮后：[10, 32, 120, 108]
     System.out.println("第一轮后：" + Arrays.toString(arr));

     //第二轮
     minIndex = 1;
     min = arr[1];
     for (int j = 1 + 1; j < arr.length; j++) {
         if (min > arr[j]) { //说看假定的最小值，并不是最小
             min = arr[j];//重置min
             minIndex = j;//重置minIndex
         }
     }
     //将最小值放在arr[0]，即交换位置
     if (minIndex != 1) {
         arr[minIndex] = arr[1];
         arr[1] = min;
     }
     //输出结果:第一轮后：[10, 32, 120, 108]
     System.out.println("第二轮后：" + Arrays.toString(arr));


     //第三轮
     minIndex = 2;
     min = arr[2];
     for (int j = 2 + 1; j < arr.length; j++) {
         if (min > arr[j]) { //说看假定的最小值，并不是最小
             min = arr[j];//重置min
             minIndex = j;//重置minIndex
         }
     }
     //将最小值放在arr[0]，即交换位置
     if (minIndex != 2) {
         arr[minIndex] = arr[2];
         arr[2] = min;
     }
     //输出结果:第一轮后：[10, 32, 120, 108]
     System.out.println("第三轮后：" + Arrays.toString(arr));
 }
}

第一轮后：[10, 32, 120, 108]
第二轮后：[10, 32, 120, 108]
第三轮后：[10, 32, 108, 120]

简化代码

package sort.demo;
import java.util.Arrays;

public class SelectSort {
public static void main(String[] args) {
    int[] arr = {108, 32, 120, 10};
    selectSort(arr);
}

//选择排序
public static void selectSort(int[] arr) {
    //原始的数组：108，32，120，10
    //第一轮排序结果：10，32，120，108

    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        int min = arr[i];
        for (int j = 0 + 1; j < arr.length; j++) {
            if (min > arr[j]) { //说看假定的最小值，并不是最小
                min = arr[j];//重置min
                minIndex = j;//重置minIndex
            }
        }
        //将最小值放在arr[0]，即交换位置
        if (minIndex != 0) {
            arr[minIndex] = arr[0];
            arr[0] = min;
        }
        //输出结果:第一轮后：[10, 32, 120, 108]
        System.out.println("第" + (i + 1) + "轮后：" + Arrays.toString(arr));
    }
}
}

测试选择排序的时间复杂度

package sort.demo;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class SelectSort {
public static void main(String[] args) {
    //测试选择排序的时间复杂度，花费的时间
    int[] arr = new int[80000];//定义数组长度
    for (int i = 0; i < 80000; i++) {
        //生成0～800000的随机整数
        arr[i] = (int) (Math.random() * 8000000);
    }

    Date date1 = new Date();
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String date1Str = simpleDateFormat.format(date1);
    System.out.println("排序前的时间是：" + date1Str);

    //冒泡排序方法调用
    selectSort(arr);

    Date date2 = new Date();
    String date2Str = simpleDateFormat.format(date2);
    System.out.println("排序后的时间是：" + date2Str);


}

//选择排序
public static void selectSort(int[] arr) {
    //原始的数组：108，32，120，10
    //第一轮排序结果：10，32，120，108

    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        int min = arr[i];
        for (int j = 0 + 1; j < arr.length; j++) {
            if (min > arr[j]) { //说看假定的最小值，并不是最小
                min = arr[j];//重置min
                minIndex = j;//重置minIndex
            }
        }
        //将最小值放在arr[0]，即交换位置
        if (minIndex != 0) {
            arr[minIndex] = arr[0];
            arr[0] = min;
        }
        //System.out.println("第" + (i + 1) + "轮后：" + Arrays.toString(arr));
    }
}
}