算法系列-选择排序

基本介绍

选择排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，在依规定交换位置后达到排序目的。
基本思想：
第一次从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次，得到一个按顺序码从小到大排列的有序序列。

代码

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {10, 6, 7, -2, -1};

        int minIndex = 0;
        int min = arr[0];
        for (int j = 0+1; j < arr.length; j++) {
            if(min > arr[j]){
                min = arr[j];
                minIndex = j;
            }
        }
        if(minIndex != 0){
            arr[minIndex] = arr[0];
            arr[0] = min;
        }
        System.out.println("第1趟排序后的数组");
        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];
                minIndex = j;
            }
        }
        if(minIndex != 1){
            arr[minIndex] = arr[1];
            arr[1] = min;
        }
        System.out.println("第2趟排序后的数组");
        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];
                minIndex = j;
            }
        }
        if(minIndex != 2){
            arr[minIndex] = arr[2];
            arr[2] = min;
        }
        System.out.println("第3趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        minIndex = 3;
        min = arr[3];
        for (int j = 3+1; j < arr.length; j++) {
            if(min > arr[j]){
                min = arr[j];
                minIndex = j;
            }
        }
        if(minIndex != 3){
            arr[minIndex] = arr[3];
            arr[3] = min;
        }
        System.out.println("第4趟排序后的数组");
        System.out.println(Arrays.toString(arr));
    }
}

查看运行结果：

第1趟排序后的数组
[-2, 6, 7, 10, -1]
第2趟排序后的数组
[-2, -1, 7, 10, 6]
第3趟排序后的数组
[-2, -1, 6, 10, 7]
第4趟排序后的数组
[-2, -1, 6, 7, 10]

整理后代码：

package com.air;

import java.util.Arrays;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {10, 6, 7, -2, -1};

        for(int i = 0; i<arr.length-1;i++) {
            int minIndex = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {
                    min = arr[j];
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
            System.out.println("第"+(i+1)+"趟排序后的数组");
            System.out.println(Arrays.toString(arr));
        }
    }
}

运行结果：

第1趟排序后的数组
[-2, 6, 7, 10, -1]
第2趟排序后的数组
[-2, -1, 7, 10, 6]
第3趟排序后的数组
[-2, -1, 6, 10, 7]
第4趟排序后的数组
[-2, -1, 6, 7, 10]

时间复杂度 通过查看代码，也是有有两个循环，其时间复杂度也是为O($n^2$)

注意：
虽然选择排序和冒泡排序时间复杂度相同，选择排序算法是比冒泡排序要快的。