选择排序--通俗易懂

一.选择排序介绍

　　1.定义：
　　　　选择式排序也属于内部排序法，将要排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的
　　2.排序思想：
　　　　第1次从arr[0]上拿到一个值与数组中arr[1]值相比较，如果比后面的值大，则记录下arr[1]的值和下标，当本轮循环结束后找到最小值，然后将arr[0]与最小值交换位置，最小值已经找到
　　　　第2次从arr[1]上拿出一个值与数组中arr[2]值相比较，如果比后面的值大，则记录下arr[2]的值和下标，当本轮循环结束后找到最小值，然后将arr[0]与最小值交换位置，次最小值已经找到
　　　　...
　　　　这样排序的结果是，小的向前，大的向后，大大缩短的排序的周期
　　　　你细品一下

二.代码实现

　　1.分步实现

　　2.整体实现

三.时间复杂度

　　选择排序的时间复杂度是O(n-1)，也就是O(n)，比冒泡小了1个次方的规模呀！！！

实现过程：

package com.zpb.selector;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;


/**
 * @des        选择排序                                  
 * @author  zhao
 * @date    2019年10月29日下午11:57:10
 * 
 */
public class SelectorSort {
    
    public static void main(String[] args) {
        
        //创建80000个随机数组来测试
        int arr[] = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random()*8000000);
        }
//      int arr[] = {101,34,119,1};
        System.out.println("排序前：");
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        selectorSort(arr); 
        System.out.println("排序后：");
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
//      System.out.println(Arrays.toString(arr));
        
    }
    
  

分步实现

  //分步实现步骤
    private static void selectorSortStep(int arr[]) {
        
        int minIndex = 0; //基准下标：最小的下标
        int min = arr[0]; //基准值：默认arr[0]是最小的值，我们都是以这个为基准进行判断,也就是说，谁最小，谁是基准值
        
        //第1轮排序：=========================================================
        for (int j = 0 + 1; j < arr.length; j++) {//[101, 34, 119, 1]
            if(min > arr[j]) {    //说明前面的值比后面的大,要让后面的值换到前面去
                min = arr[j];    //后面的值赋值给默认的最小值
                minIndex = j;    //将后面的下标赋值给最小值的基准下标
            }
        }
        //在一轮排序完成后，min会找到一个最小值，minIndex是最小值的下标，
        //如果arr[0]就是当前最小的，那么我们也需要将其进行交换位置
        arr[minIndex] = arr[0];    //minIndex是最小值的下标，arr[minIndex]就是最小值的位置，找到最小值的位置后，就需要将arr[0]放到最小值的位置上，进行交换
        arr[0] = min;            //第1轮排序完成后,min是最小值，也是基准值，因此将min值 赋值给arr[0]
        //第1轮排序，找到第1个
//        System.out.println("第1轮排序是："+Arrays.toString(arr));    //[1, 34, 119, 101]
        
        
        //第2轮排序：=========================================================
        //在第1轮排序中，我们找到了arr[0]是最小的位置，下面我们从arr[1]上开始
        minIndex = 1;
        min = arr[1];
        for (int j = 1 + 1; j < arr.length; j++) {    //[1, 34, 119, 101]
            if(min > arr[j]) {    
                min = arr[j];    
                minIndex = j;    
            }
        }
        arr[minIndex] = arr[1];    //minIndex是最小值的下标，arr[minIndex]就是最小值的位置，找到最小值的位置后，就需要将arr[0]放到最小值的位置上，进行交换
        arr[1] = min;            //第1轮排序完成后,min是最小值，也是基准值，因此将min值 赋值给arr[0]
        //第2轮排序，由于34没有比后面的数据大，所以第2轮没有发生交换
//        System.out.println("第2轮排序是："+Arrays.toString(arr));    //[1, 34, 119, 101]    
        
        //第3轮排序：=========================================================
        minIndex = 2;
        min = arr[2];
        for (int j = 2 + 1; j < arr.length; j++) {//[1, 34, 119, 101]    
            if(min > arr[j]) {    //说明前面的值比后面的大,要让后面的值换到前面去
                min = arr[j];    //后面的值赋值给默认的最小值
                minIndex = j;    //将后面的下标赋值给最小值的基准下标
            }
        }
        arr[minIndex] = arr[2];    
        arr[2] = min;            
//      System.out.println("第3轮排序是："+Arrays.toString(arr));    //[1, 34, 101,119]    
        
    }
}

 整体实现

 //整体实现
 private static void selectorSort(int[] arr) {
        
        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;    //将后面的下标赋值给最小值的基准下标
                }
            }
            arr[minIndex] = arr[i];
            arr[i] = min;
        }
    }