Java数据结构与算法之选择排序的小练习

选择排序的基本思想：
选择排序 (select sorting）也是一种简单的排序方法。它的基本思想是：
第一次以arr[0]~arr[n-1]中选取最小值，与arr{0]交换，第二次从arr[1]~~arr[n-1]中选取最小值，与arr[2]交换，
第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换，⋯，第i次从arr[i-1J~arr [n-1]中选取最小值，
与arr[i-1]交换，⋯,第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]
交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
选择排序的规则：
1.选择排序一共有数组大小-1轮排序
2.1每一轮排序，又是一个循环
2.2然后和后面的每个数进行比较，如果发现有比当前数更小的数，就重新确定最小数，并获得下标
2.3当遍历到数组的最后时，就得到本轮最小数和下标

package com.wrx.dataStructures.sort;
import java.util.Arrays;
/**
 * @auther Len901
 * @time 2022-10-02-19:56
 */
/*
选择排序的基本思想：
选择排序 (select sorting）也是一种简单的排序方法。它的基本思想是：
第一次以arr[0]~arr[n-1]中选取最小值，与arr{0]交换，第二次从arr[1]~~arr[n-1]中选取最小值，与arr[2]交换，
第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换，⋯，第i次从arr[i-1J~arr [n-1]中选取最小值，
与arr[i-1]交换，⋯,第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]
交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
选择排序的规则：
1.选择排序一共有数组大小-1轮排序
2.1每一轮排序，又是一个循环
2.2然后和后面的每个数进行比较，如果发现有比当前数更小的数，就重新确定最小数，并获得下标
2.3当遍历到数组的最后时，就得到本轮最小数和下标
 */
public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        int[] arr2 = {101, 34, 119, 1};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr2));
        selectSort(arr);
        selectSort2(arr2);
    }

    //选择排序的方法
    public static void selectSort(int[] arr) {
        //分步骤解法:
        //原始的数组：101,34,119,1
        //第一轮排序：1，34，119，101
        System.out.println("分步骤解法:");
        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;
        }
        System.out.print("第一轮后：");
        System.out.println(Arrays.toString(arr));
        //第二轮排序：1，34，119，101
        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[1],即交换
        if (minIndex != 1) {
            arr[minIndex] = arr[1];
            arr[1] = min;
        }
        System.out.print("第二轮后：");
        System.out.println(Arrays.toString(arr));
        //第三轮排序：1，34，101, 119
        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[1],即交换
        if (minIndex != 2) {
            arr[minIndex] = arr[2];
            arr[2] = min;
        }
        System.out.print("第三轮后：");
        System.out.println(Arrays.toString(arr));
    }
    public static void selectSort2(int[] arr2){
        //快速解法：
        System.out.println("快速解法:");
        //在推到的过程中，我们发现了规律，因此，可以用for循环来解决
        for(int i=0;i<arr2.length-1;i++){
            int minIndex2=i;
            int min2=arr2[i];
            for(int j=i+1;j<arr2.length;j++){
                if (min2>arr2[j]){//说明假定的最小值，并不是最小
                    min2=arr2[j];//重置min
                    minIndex2=j;//重置minIndex
                }
            }
            //将最小值，放在arr[0],即交换
            if(minIndex2!=i){
                arr2[minIndex2]=arr2[i];
                arr2[i]=min2;
            }
            System.out.print("第"+(i+1)+"轮后：");
            System.out.println(Arrays.toString(arr2));
        }
    }
}