三种排序算法：选择排序，冒泡排序，插入排序

1.选择排序

/**
 * 选择排序
 * */
public class SelectionSortDemo {

    /***
     * 选择排序：一轮，将最小的挑出来，放在最前面,将第一个索引，依次与后面的每一个索引比较
     * 假设有一个数组，要求按照从小到大的顺序排列
     * 第一轮，将索引0，与索引1比较,如果比索引0小则调换位置，
     *        然后依次继续将索引0与后面的继续比较，直到与数组最后一个数字比较，最后将最小的数字放在了索引0的位置。
     *        内层循环，控制的是与索引0比较的次数，从索引1到数组的最后一个索引array.length
     * 后面的轮次，从索引1开始，继续如此，最后索引1放的是数值第二小的数字
     *        外层循环，控制的是比较的轮次，从索引0到数组倒数第二个索引array.length-1
     *
     * */
    public static void main(String[] args) {
        int[] array = {1,3,5,8,2,4,6,7};
        printArray(array);
        selectionSort(array);
        printArray(array);
    }

    /**
     * 打印数组
    * */
    public static void printArray(int[] array){
        for (int i=0;i<array.length;i++){
            System.out.print(array[i]+"\t");
        }
        System.out.println();
    }

    /**
     * 选择排序
     * */
    public static void selectionSort(int[] array){
        for (int i=0;i<array.length-1;i++){
            for (int j=i+1;j<array.length;j++){
                if(array[i]>array[j]){
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
    }
}

2.冒泡排序

/**
 * 冒泡排序
 * */
public class BubbleSortDemo {

    /***
     * 冒泡排序：一轮，将最大的挑出来，放在最后面，相邻两个依次比较
     * 假设有一个数组，要求按照从小到大的顺序排列
     * 第一轮，索引0与索引1比较，大则调换位置，索引1与索引2继续比较，相邻两个依次比较，最后将最大的放在最后面
     *        内循环控制每一轮比较，比较多少个，因为每一轮会选择出最大的一个在最后面，所以每一轮都会从索引0开始，
     *        而且都会依次少后面的一个不用比较
     * 以后每一轮，都会从索引0开始比较，但最后面都会再少一个
     *        外循环控制的是从索引0开始，比较到倒数第二个（倒数第二个与倒数第一个会比较，倒数第一往后没有比较的了）
     *
     * */
    public static void main(String[] args) {
        int[] array = {1,3,5,8,2,4,6,7};
        printArray(array);
        bubbleSort(array);
        printArray(array);
    }

    /**
     * 打印数组
    * */
    public static void printArray(int[] array){
        for (int i=0;i<array.length;i++){
            System.out.print(array[i]+"\t");
        }
        System.out.println();
    }

    /**
     * 冒泡排序
     * */
    public static void bubbleSort(int[] array){
        for (int i=0;i<array.length-1;i++){
            for (int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    int temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }
        }
    }
}

3.插入排序

/**
 * 插入排序
 * 插入排序是局部排序的方式，效率比冒泡排序和选择排序都高
 * 效率：插入排序>选择排序>冒泡排序
 *
 * 说明：
 *     1.假设有数组{3,5,1,4,7,6}
 *     2.将第二个元素5拿出来，需要往左边插，但插哪里需要找一下，
 *       要与左边的局部有序元素数组依次比较，从右往左依次比较，先与上一个元素3进行比较，此时数组{3，5，1,4,7，7}，5
 *     3.将临时保存的元素5与3比较，5比3大，则3不用移动，5放置到原来的位置。{3,5,1,4,7,6}
 *       好了，结束本次循环。
 *     4.将第三个元素1拿出来，需要往左边插，但插哪里需要找一下，此时数组{3，5，1,4,7，6}，1
 *       要与左边的局部有序元素数组依次比较，从右往左依次比较，先与上一个元素5进行比较，
 *       1比5小，则此时数组{3，5，5,4,7，6}，1;
 *       然后继续与上上一个元素3比较，1比2小，则此时数组为{3,3,5,4,7,6}，1；
 *       发现左边没值了，则将1放到最后一次比较的元素位置上，即{1,3,5,4,7,6}，
 *       好了，结束本次循环
 *     5.继续如此，直至结束。
 *
 * Created by xuruanshun on 2019/8/27.
 */
public class InsertSort {

    // {3,5,1,4,7,6}
    // 插入排序算法
    public void insertSort2(int[] array){
        int i,j,temp;
        /**
         * 第一个for循环，
         * 把数组分成两个部分，右边为未排序，左边为已排序
         * 记录排序与未排序分割点temp（temp为下一个排序对象）
         *
         * */
        for(i=1;i<array.length;i++){
            temp = array[i];//3
            /**
             * 第二个for循环
             * 将排序对象temp与已排序数组比较
             * 当temp比最近左边的数大时（按从小到大循序排列时）
             * 直接结束本次循环，进行下一个数排序
             * 否则比左边这个数小时将这个数后移，腾出这个数的位置
             */
            for(j=i-1;j>=0;j--){
                if(temp>array[j]){
                    break;
                }else {
                    array[j+1]=array[j];
                }
            }
            array[j+1]=temp;
        }
    }
}