选择排序

 

排序步骤（有n个数需要排序） 

在一组序列中找到最大/小的元素，将其与序列的起始位置交换；此时可进一步缩小排序范围，将改序列的起始位置移出；寻找剩余范围序列中的最大/小值，与此时序列的其实位置交换；以此类推，直到所有的元素排序完成

第一轮从1~n 的元素中选取最小值，若小于第一个数，则交换

第二轮从2~n 的元素中选取最小值，若小于第二个数，则交换

依次类推……

解析说明

时间复杂度为O(N^2) 

选择排序需要嵌套两层for循环来控制：外层循环控制已经排好序的数字的个数，内层循环控制剩余所需要排序的范围

比较次数O(n^2)：总的比较次数N = (n-1) + (n-2) +…+ 1 = n x (n-1)/2

交换次数O(n)：最好情况是，已经有序，交换0次；最坏情况是，逆序，交换n-1次（所有的数恰好不在对应的位置上，也就是每个位置都要找到此位置上的数）

空间复杂度为O(1) 

所有的操作均为数组间位置的交换

public static int[] selectSort(int[] arr){
        int min = 0;//最小值的索引，暂定为起始位置
        for (int i = 0; i < arr.length-1; i++) {
            min = i;//起始位置索引
            for (int j = i+1; j < arr.length; j++) {
                if(arr[min] > arr[j]){//出现一个比起始位置小的数字，就与起始位置进行交换
                    swap(arr,min,j);
                }
            }
        }
        return arr;
    }

优化

在确定数的一轮中，同时确定最大和最小值，划定一个大于起始位置、小于末尾位置的一个范围，可以将循环的次数减少至n/2

//优化：同时确定最大和最小值
    public static int[] selectSort1(int[] arr) {
        int max = arr.length - 1, min = 0;//最大、最小值的初始位置
        for (int i = 0; i < arr.length / 2; i++) {
            min = i;
            max = arr.length - i - 1;//min和max关于序列的中心保持对称
            if (arr[min] > arr[max]) {
                swap(arr, min, max);
            }
            for (int j = i + 1; j < max; j++) {
                if (arr[min] > arr[j]) {//j所在位置的数小于最小值，与min交换
                    swap(arr, min, j);
                }
                if (arr[max] < arr[j]) {//j所在位置的数大于最大值，与max交换
                    swap(arr, max, j);
                }
            }
        }
        return arr;
    }

选择排序代码

import org.junit.Test;

public class SelectSort {
    @Test
    public void test() {
        int[] arr = new int[]{12, 15, 4, 5, 8, 35};
        selectSort1(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    public static int[] selectSort(int[] arr) {
        int min = 0;//最小值的索引，暂定为起始位置
        for (int i = 0; i < arr.length - 1; i++) {
            min = i;//起始位置索引
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[min] > arr[j]) {//出现一个比起始位置小的数字，就与起始位置进行交换
                    swap(arr, min, j);
                }
            }
        }
        return arr;
    }


    //优化：同时确定最大和最小值
    public static int[] selectSort1(int[] arr) {
        int max = arr.length - 1, min = 0;//最大、最小值的初始位置
        for (int i = 0; i < arr.length / 2; i++) {
            min = i;
            max = arr.length - i - 1;//min和max关于序列的中心保持对称
            if (arr[min] > arr[max]) {
                swap(arr, min, max);
            }
            for (int j = i + 1; j < max; j++) {
                if (arr[min] > arr[j]) {//j所在位置的数小于最小值，与min交换
                    swap(arr, min, j);
                }
                if (arr[max] < arr[j]) {//j所在位置的数大于最大值，与max交换
                    swap(arr, max, j);
                }
            }
        }
        return arr;
    }

    public static void swap(int[] data, int a, int b) {
        int temp = data[a];
        data[a] = data[b];
        data[b] = temp;
    }
}