数据结构与算法单排日记-2020/3/21-排序算法&选择排序

基本思想

第一次从 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]交换，
…,
第n-1次从 arr[n-2] 到 arr[n-1] 中选取最小值，与arr[n-2]交换，
总共通过n-1次，
得到一个按排序码从小到大排列的有序序列。

选择排序的思路图解

说明：

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

冒泡排序过程代码：

import java.util.Arrays;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        selectSort(arr);
    }

    //选择排序方法
    public static void selectSort(int[] arr) {

        /**
         * 第1轮的排序 1 34 119 101
         */
        int min = arr[0];//假定最小值是arr[0]
        int minIndex = 0;//最小值的坐标
        for (int i = 0 + 1; i < arr.length; i++) {
            if (min > arr[i]) {//说明假定的最小值，并不是最小
                min = arr[i];//重置min
                minIndex = i;//重置minIndex
            }
        }
        //将最小值，放在arr[0]，即交换
        if (minIndex != 0) {
            arr[minIndex] = arr[0];
            arr[0] = min;
        }
        System.out.println("第1轮结果：" + Arrays.toString(arr));

        /**
         * 第2轮的排序 1 34 119 101
         */
        min = arr[1];//假定最小值是arr[1]
        minIndex = 1;//最小值的坐标
        for (int i = 0 + 1 + 1; i < arr.length; i++) {
            if (min > arr[i]) {//说明假定的最小值，并不是最小
                min = arr[i];//重置min
                minIndex = i;//重置minIndex
            }
        }
        //将最小值，放在arr[1]，即交换
        if (minIndex != 1) {
            arr[minIndex] = arr[1];
            arr[1] = min;
        }
        System.out.println("第2轮结果：" + Arrays.toString(arr));

        /**
         * 第3轮的排序 1 34 101 119
         */
        min = arr[2];//假定最小值是arr[1]
        minIndex = 2;//最小值的坐标
        for (int i = 0 + 1 + 1 + 1; i < arr.length; i++) {
            if (min > arr[i]) {//说明假定的最小值，并不是最小
                min = arr[i];//重置min
                minIndex = i;//重置minIndex
            }
        }
        //将最小值，放在arr[2]，即交换
        if (minIndex != 2) {
            arr[minIndex] = arr[2];
            arr[2] = min;
        }
        System.out.println("第3轮结果：" + Arrays.toString(arr));
    }
}

冒泡排序代码（循环）：

import java.util.Arrays;

public class SelectSort02 {
    public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        selectSort(arr);
    }

    public static void selectSort(int[] arr) {

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

• 程序运行时间检测：

import java.util.Arrays;

public class SelectSort02 {
    public static void main(String[] args) {
        int[] arr = new int[8000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 80000);
        }

        long startTime = System.currentTimeMillis(); //获取开始时间doSomething(); //测试的代码段
        selectSort(arr);
        long endTime = System.currentTimeMillis(); //获取结束时间
        System.out.println("程序运行时间：" + (endTime - startTime) + "ms"); //输出程序运行时间
    }

    public static void selectSort(int[] arr) {

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