【数据结构】排序算法-选择排序(Select Sorting)

• 基本思想:

• 拿arr[0]先和每个元素比,比自己小的话就交换,确定第一个最小值;

• 拿arr[1]和每个元素比,比自己小的话就交换,确定第二个最小值;

• 以此类推.

• 使用逐步推导的方式，讲解选择排序

package com.fly.o;
import java.util.Arrays;
/**
 * @Title: 选择排序
 * @author: Fly
 * @date: 2020/3/29 - 13:32
 */
public class SelectSort {
    public static void main(String[] args) {
        selectSort();
    }
    public static void selectSort(){
        //使用逐步推导的方式，讲解选择排序
        int[] arr={101,34,119,1};
        //第一轮
        //拿arr[0]找最小值
        int minIndex=0;
        int min=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (min>arr[i]){
                min=arr[i];
                minIndex=i;
            }
        }
        //将arr[0]的值放在最小值的地方
        arr[minIndex]=arr[0];
        //将上面找到的最小值min（temp）放在arr[0]
        arr[0]=min;
        System.out.println("第一轮：");
        System.out.println(Arrays.toString(arr));//[1, 34, 119, 101]

        //第二轮
        //拿arr[1]找最小值
        minIndex=1;
        min=arr[1];
        for (int i = 1+1; i < arr.length; i++) {
            if (min>arr[i]){
                min=arr[i];
                minIndex=i;
            }
        }
        //如果最小值的下标就是原来的下标，也就是没有交换，则不用交换
        if (minIndex!=1){
            //将arr[0]的值放在最小值的地方
            arr[minIndex]=arr[1];
            //将上面找到的最小值min（temp）放在arr[0]
            arr[1]=min;
        }
        System.out.println("第二轮：");
        System.out.println(Arrays.toString(arr));//[1, 34, 119, 101]

        //第三轮
        //拿arr[2]找最小值
        minIndex=2;
        min=arr[2];
        for (int i = 1+2; i < arr.length; i++) {
            if (min>arr[i]){
                min=arr[i];
                minIndex=i;
            }
        }
        //如果最小值的下标就是原来的下标，也就是没有交换，则不用交换
        if (minIndex!=2){
            //将arr[0]的值放在最小值的地方
            arr[minIndex]=arr[2];
            //将上面找到的最小值min（temp）放在arr[0]
            arr[2]=min;
        }
        System.out.println("第三轮：");
        System.out.println(Arrays.toString(arr));//[1, 34, 101, 119]
    }
}

把一二三轮的代码改善:

public class SelectSort {
    public static void main(String[] args) {
        selectSort1();
    }

    public static void selectSort1(){
        int[] arr={101,34,119,1};

        for (int j = 0; j < arr.length-1; j++) {
            int minIndex=j;
            int min=arr[j];
            for (int i = 1+j; i < arr.length; i++) {
                if (min>arr[i]){
                    min=arr[i];
                    minIndex=i;
                }
            }
            if (minIndex!=j){
            //将arr[0]的值放在最小值的地方
            arr[minIndex]=arr[j];
            //将上面找到的最小值min（temp）放在arr[0]
            arr[j]=min;}
            System.out.println("第"+(j+1)+"轮：");
            System.out.println(Arrays.toString(arr));//[1, 34, 119, 101]
        }
    }

这里可以看到是两个for循环嵌套,所以选择排序的时间复杂度就是O(n²).

排序速度为什么比冒泡排序快

虽然时间复杂度和冒泡排序一样,但是排序速度比冒泡排序快.
因为冒泡排序每轮每相邻的元素逆序就交换,选择排序是先记录最小值,在一轮中最后再交换,所以是每轮一交换.
如果这里题目要求改成从大到小排序,则需要把内嵌的for循环改成<就可以

 for (int i = 1+j; i < arr.length; i++) {
                if (min < arr[i]){
                    min=arr[i];
                    minIndex=i;
                }
            }