选择排序--通俗易懂

一.选择排序介绍

  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;
        }
    }

猜你喜欢

转载自www.cnblogs.com/MrRightZhao/p/11795059.html