关于几种排序算法

1:选择排序

通俗理解，每次从未排序的数组中选择一个最大或者最小值放在合适位置
1）定下最小位置在哪里？开始最小位置是0，去1到N-1范围内去找最小值；
数组的范围是0-N-1
第一个for的范围是0~N-2
2）第二个for的终点是数组末尾

public class SelectSort {
    public static void main(String[] args) {
        int[] ints = genArray(15, 18);
        selectSort(ints);
        for (int i=0;i<ints.length;i++){
            System.out.println(ints[i]);
        }
    }


    public static int[] genArray(int maxsize,int maxValue){
        int j = (int) (maxsize * Math.random());
        int[] arr1=new int[j];
        for (int i=0;i<arr1.length;i++){
            arr1[i]= (int) ((int)(maxValue+1)*(Math.random())-(int)(maxValue)*(Math.random()));
        }
        return arr1;
    }

    public static void selectSort(int[] arrs){
        for (int i=0;i<arrs.length-1;i++){
            int MaxIndex=i;
            for (int j=i+1;j<arrs.length;j++){
                if (arrs[j]>arrs[MaxIndex]){
                    MaxIndex=j;
                }
            }
            swap(arrs,i,MaxIndex);
        }
    }
    private static void swap(int[] arrs, int i, int minIndex) {
        //交换位置
        int temp = arrs[i];
        arrs[i] = arrs[minIndex];
        arrs[minIndex]=temp;
    }
}

2:冒泡排序

理解为相邻两个数两两进行比较，每一轮下来会把最值放到尾部
1）第一个for是限制两两比较的范围，初始的范围上限是N-1，下限是1
2）遍历0到N-1，比较相邻的两个数，交换位置

/**
 * 关于冒泡排序
 * 数组的整体范围是0~N-1
 *第一次会让数组的范围是0~N-2无序，找到最大的一个值放到最右边（两两进行比较，大的数据放到右边）
 * 第二次会让数组的范围是0~N-3无序，找到最大的一个值放到最右边倒数第二个位置（两两进行比较，大的数据放到右边）
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arrs={3,2,1,5,6,9};
        bubbleSort(arrs);
        for (int i=0;i<arrs.length;i++){
            System.out.println(arrs[i]);
        }
    }
    public static void bubbleSort(int[] arrs){
        if (arrs==null || arrs.length<2){
            return;
        }
        for (int i=arrs.length-1;i>0;i--){
            for (int j=0;j<i;j++){ //i如果是1, 0小于1
                if (arrs[j]>arrs[j+1]){//前一个数大于后一个数，交换
                    swap(arrs,j,j+1);
                }
            }
        }
    }

    /**
     *
     * @param arrs,待交换的数组
     * @param j 前一个数
     * @param k 后一个数
     */
    private static void swap(int[] arrs,int j,int k) {
        int temp=arrs[j];
        arrs[j]=arrs[k];
        arrs[k]=temp;
    }
}

3:插入排序

理解成将某个数插入到已经排序的数组中
1）第一个for从1开始，代表要在哪些范围上实现有序，0-0上已经有序，初始目标是0-1上有序
2）第二个for从第一个for范围的末尾开始，向数组前面看如果是满足要求的大小关系就开始交换 （同时需要满足下标大于0，最后一次是比较1与0之间的大小关系）

/**
/**
 * 关于插入排序？
 * 先让0-0上有序
 * 再让0-1上有序
 * 再让0-2上有序
 * ....
 * 0-N-2上有序，把N-1下标的值插入到数组中，进行排序插入到数组中
 * 插入排序
 * 想让0-N-1上有序
 */
public class InsertionSort {
    public static void main(String[] args) {
        int[] arrs = {2, 0, 1, 3, 4, 9};
        insertionSort(arrs);
        for (int i = 0; i < arrs.length; i++) {
            System.out.println(arrs[i]);
        }
    }

    public static void insertionSort(int[] arrs) {
        //第一个for是用来确定要在哪个范围上实现有序
        //0到0上本来就是有序的；接下来去实现0-1上有序
        //如何去实现0-1上有序呢？把1这个位置的数，和他前面的那个数进行比较
        //如果这个数比前一个数小，就交换位置，一直到，这个数不在比前一个数小或者到达数组的头部
        //就停止
        for (int i = 1; i < arrs.length; i++) { //向让0-1上的数有序
            /**
             * 这个位置注意使用&&；在前一个为false的情况下；就不在去对后面的条件进行判断，从而
             * 避免下标的外泄问题；如果换成了&，在第一个false的情况下，此时如果j=0;
             * 那么就会造成j-1=-1 去索引下标为-1的值
             * 这样就会报错
             */
            for (int j = i; j > 0 && arrs[j] < arrs[j - 1]; j--) {
                swap(arrs, j - 1, j);
            }
        }
    }

        private static void swap ( int[] arrs, int i, int j){
            int temp = arrs[i];
            arrs[i] = arrs[j];
            arrs[j] = temp;
        }
    }