(基础)选择排序 插入排序

Tools类去掉一些重复的操作:

package Algorithms;

import java.lang.reflect.Method;
import java.util.Random;

/**
 * 排序的工具类
 * Creator : LaiHaoDa
 * Date    : 2018-07-05 10:07
 */
public class SortTools {

    /**
     * 数组坐标间的交换
     * @param arr
     * @param last
     * @param next
     */
    public static void swapArr(int[] arr,int last,int next){
        //当前坐标 与 最小坐标的比较  相等则不互换
        if(last == next) return;
        int z = arr[last];
        arr[last] = arr[next];
        arr[next] = z;
    }



    /**
     * 生成一个随机数组（整型）
     * @param size
     * @param min
     * @param max
     * @return
     */
    public static int[] getRandArr(int size,int min,int max){
        int[] arr=new int[size];
        int minute=max-min;
        Random random =new Random();
        for(int k=0;k<size;k++){
            //产生一个[min,max]之间的随机数
            arr[k]=random.nextInt(minute)+min+1;
        }
        return arr;
    }



    /**
     * 打印数组的内容
     * @param arr
     */
    public static void printArr(int[] arr){
        StringBuilder builder = new StringBuilder();
        for(int i:arr){
            builder.append("  "+i);
        }
        System.err.println(builder.toString());
    }





    /**
     * 进行获取排序算法的消耗时间，以比较性能
     * @param arr
     * @param cls
     * @param methodName
     */
    public static void consumeTime(int[] arr,Class cls,String methodName){
        //通过反射机制 运行函数
        try {
            //通过排序函数class对象获取排序的方法
            Method sortMethod = cls .getMethod(methodName,new Class[]{int[].class});
            //排序参数只有一个，是可毕竟数组arr
            long start = System.currentTimeMillis();
            sortMethod.invoke(null,arr);
            long end = System.currentTimeMillis();
            System.err.println(String.format("%s , consume time  : %d ms",cls.getSimpleName(),(end-start) ));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 校验排序结果是否正确
     * @param arr
     * @return
     */
    public static boolean isSortRight(int arr[]){
        boolean flag= true;
        for(int k=0,total=arr.length ; k<(total-1) ; k++){
            if(arr[k]>arr[k+1]){
                flag = false;
                break;
            }
        }
        System.err.println("排序的结果  :  "+flag);
        return flag;
    }



}

选择排序:

package Algorithms;

/**
 * 选择排序函数  n(o^2)  【基础】
 */
public class SelectionSort {


    public static void main(String[] args) {

        int[] arr = SortTools.getRandArr(1000,1,100);
        SortTools.printArr(arr);

        SortTools.consumeTime(arr, SelectionSort.class,"sort");

        sort(arr);
        SortTools.isSortRight(arr);

        SortTools.printArr(arr);


    }


    /**
     * 选择排序算法
     *    思路：从左往右轮询，在第二级轮询与第一级坐标值相比较（直达第二级轮询完则拿到最终的最小坐标值）
     *          发生与当前坐标与最小坐标值的互换
     * @param arr
     */
    public static void sort(int[] arr){
        for(int j = 0,size = arr.length;j<size;j++){
            int temp=j;
            for(int k=j+1;k<size;k++){
                //寻找最小的坐标 往后推
                if(arr[temp]>arr[k]){
                    temp=k;
                }
            }
            //一次轮循环拿到最小值的坐标值
            SortTools.swapArr(arr,j,temp);
        }
    }




}

package Algorithms;

/**
 * 插入算法
 * Creator : LaiHaoDa
 * Date    : 2018-07-05 10:51
 */
public class InsertSort {

    public static void main(String[] args) {

        int[] arr = SortTools.getRandArr(1000,1,100);
        SortTools.printArr(arr);

        SortTools.consumeTime(arr, InsertSort.class,"sort");
        SortTools.consumeTime(arr, SelectionSort.class,"sort");

        sort(arr);
        SortTools.isSortRight(arr);

        SortTools.printArr(arr);

    }


    /**
     * 插入排序算法
     *    A B C D
     *    ---->
     *        第一种:正常插入算法
     *        1. A>B   B A
     *        2. A>C   B C A   B>C  C B A
     *        3  ...
     *    思路：从左往右轮询，坐标=1开始进行比较(第一次轮询取的k数组区间与下一个轮询(从大到小)内容第k+1进行比较内容)
     * @param arr
     */
    public static void sort(int[] arr){
        int size = arr.length;
        for(int k = 1;k < size;k++){
            for (int z=k;z>0;z--){
                if(arr[z] < arr[z-1])
                    SortTools.swapArr(arr,(z-1),z);
                else
                    break;
            }
        }
    }
}