排序算法-选择排序

排序算法-选择排序，java实现排序排序，算法图形化图解排序步骤。

---

排序思想

1. 遍历比较，选出数组中最小的元素，放在数组的第1个位置（即与数组第1位置的元素交换位置）
2. 然后在从数组第2的位置开始遍历比较，找出剩下数组中最小的元素，放在数组的第2个位置（即与数组第2位置的元素交换位置）
3. 依次类推，直到将数组的所有元素排序完成

算法图形化

测试数据：data[]=${arr}

代码实现

排序代码：

/**
 * @description 选择排序算法实现
 * @author dxy
 * @date 2019-12-19
 */
@Service("selectionSortService")
public class SelectionSortServiceImpl implements ISelectionSortService {

    /**
     * 选择排序算法：
     * 1.遍历比较，选出数组中最小的元素，放在数组的第1个位置（即与数组第1位置的元素交换位置）
     * 2.然后在从数组第2的位置开始遍历比较，找出剩下数组中最小的元素，放在数组的第2个位置（即与数组第2位置的元素交换位置）
     * 3.依次类推，知道将数组的所有元素排序完成
     * @param
     * @throws Exception
     */
    @Override
    public List<SelectionSortResult> sort(Comparable[] arrays) throws Exception {

        //将数组随机打乱
        //StdRandom.shuffle(arrays);

        //打印数组
        SortUtil.show(arrays);
        //数组长度
        int arrayLength = arrays.length;

        for(int i = 0; i < arrayLength-1; i++) {
            //最小数的下标
            int minIndex = i;

            for(int j = i + 1; j < arrayLength; j++) {
                //比较获得最小值
                if (less(arrays[j], arrays[minIndex])) {
                    //最小下标赋值
                    minIndex = j;
                }
            }
            //如果拿去的数就是最小数，不需要交换
            if (i != minIndex) {

                //最小数交换到遍历位置
                exch(arrays, i, minIndex);

                //打印数组
                SortUtil.show(arrays);


            } else {

                //不交换

            }
        }
        //验证是否有序
        assert SortUtil.isSorted(arrays);

        return resultList;

    }

工具类：

/**
 * @description 排序工具类
 * @author dxy
 * @date 2019-12-11
 */
public class SortUtil {

    /**
     * 元素比较
     * @param var0
     * @param var1
     * @return var0<var1 则返回true
     */
    public static boolean less(Comparable var0, Comparable var1) {
        return var0.compareTo(var1) < 0;
    }

    public static boolean less(Object v, Object w, Comparator comparator) {
        return comparator.compare(v, w) < 0;
    }

    /**
     * 元素比较
     * @param var0
     * @param var1
     * @param var2
     * @return
     */
    public static boolean less(Comparable[] var0, int var1, int var2) {
        return var0[var1 - 1].compareTo(var0[var2 - 1]) < 0;
    }


    /**
     * 元素交换
     * @param var0 数组
     * @param var1 下标1
     * @param var2 下标2
     */
    public static void exch(Object[] var0, int var1, int var2) {
        Object var3 = var0[var1];
        var0[var1] = var0[var2];
        var0[var2] = var3;
    }

    /**
     * 数组是否有序
     * @param var0
     * @return
     */
    public static boolean isSorted(Comparable[] var0) {
        return isSorted(var0, 0, var0.length - 1);
    }

    public static boolean isHsorted(Comparable[] var0, int var1) {
        for(int var2 = var1; var2 < var0.length; ++var2) {
            if (less(var0[var2], var0[var2 - var1])) {
                return false;
            }
        }

        return true;
    }

    /**
     * 判断数组中元素1到元素2是否有序
     * @param var0 数组
     * @param var1 元素1
     * @param var2 元素2
     * @return
     */
    public static boolean isSorted(Comparable[] var0, int var1, int var2) {
        for(int var3 = var1 + 1; var3 <= var2; ++var3) {
            if (less(var0[var3], var0[var3 - 1])) {
                return false;
            }
        }

        return true;
    }

    /**
     * 遍历打印数组换行
     * @param var0
     */
    public static void showLn(Comparable[] var0) {
        for(int var1 = 0; var1 < var0.length; ++var1) {
            System.out.println(var0[var1]);
        }

    }

    /**
     * 遍历打印数组不换行
     * @param var0
     */
    public static void show(Comparable[] var0) {
        for(int var1 = 0; var1 < var0.length; ++var1) {
            System.out.print(var0[var1]+"  ");
        }
        System.out.println();

    }
}