冒泡排序，选择排序，插入排序

冒泡排序
冒泡排序代码如下：

冒泡排序代码思路如下：

package com.javasm.array;
import java.util.Arrays;
/**
 * @author: JAVASM
 * @classNAME: ArrayDemo07
 * @description:
 * @date: 2021/3/29 22:10
 * @version:0.1
 * @since:1.8
 */
public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] array={88,66,99,77,33,11,6,8,9};
        int len=array.length;
        for (int i = 1; i < len; i++) {
            for(int j=0;j<len-i;j++){
                if(array[j]<array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
}
代码结果输出如下：
[99, 88, 77, 66, 33, 11, 9, 8, 6]

Process finished with exit code 0

选择排序

选择排序（仔细看代码里的注释，详细理解）

1. 从左往右，每次排好一个左边的元素
2. 第一层for循环用于进行数组长度次比较，控制循环比较的轮数
3. 第二层for循环用于每轮循环比较，每轮在最左边得出一个最小值，每次比较的元素个数都减1，每次找出一个新的最小元素
4. 第一轮循环控制比较数组长度次，第二层循环控制将每轮的最小元素依次与剩余右边每个元素进行比较，如果发现更小的了，就将min和索引换成新的最小值，到每一大轮循环结束，将最终得到的最小值与每一大轮定义的第i个元素通过t=a;a=b;b=t进行替换， 但是要注意代表a，b，t元素的作用域。
   

package com.javasm.array;
import java.util.Arrays;
/**
 * @author: JAVASM
 * @classNAME: ArrayDemo07
 * @description:
 * @date: 2021/3/29 22:10
 * @version:0.1
 * @since:1.8
 */
public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] array={88,66,99,77,33,11,6,8,9};
        int len=array.length;
        int minIndex=0;
        //第一层for循环用于每次的比较
        for (int i = 0; i < len-1; i++) {
            //第二层for循环用于每次从左到右比较数组元素
                int min=array[i];
                minIndex=i;
            for(int j=i+1;j<len;j++){
                //如果发现新的最小值就将索引定位到新的元素位置
                if(min>array[j]){
                    min=array[j];
                    minIndex=j;
                }
            }
            //从左往右，每次排好一个左边的元素
            // 第一层for循环用于进行数组长度次比较，控制循环比较的轮数
            // 第二层for循环用于每轮循环比较，每轮在最左边得出一个最小值，每次比较的元素个数都减1，每次找出一个新的最小元素
            //array[j]在出了for循环之后就已经失效了，因此尽量提升变量的作用域，array[minIndex]和min就是array[j]
            // 但是要将array[i]的值和当前索引位置的值进行交换，且array[minIndex]不能换成min，因为要将索引单元找到的最小值交换为每最外层循环需要更新的值
            int temp=array[i];
            //增加if条件判断，只有在每次最后发现找到的最小值与当前元素不同时才执行交换，如果相同则说明当前最外层for循环需要排序的array[i]就是最小值，不需要交换最小值到左边
            if(temp!=min) {
                array[i] = min;
                array[minIndex] = temp;
            }
        }
        System.out.println(Arrays.toString(array));
    }
}
代码输出结果如下：
[6, 6, 6, 6, 6, 6, 6, 8, 9]

Process finished with exit code 0

插入排序（搞不懂就单点调试）

package com.javasm.array;


import java.lang.reflect.Array;
import java.util.Arrays;

/**
 * @author: JAVASM
 * @classNAME: ArrayDemo09
 * @description:
 * @date: 2021/3/30 13:43
 * @version:0.1
 * @since:1.8
 */
public class ArrayDemo09 {
    public static void main(String[] args) {
        int[] array={88,66,25,61};
        int len=array.length;
        System.out.println("排序之前数组的值为"+ Arrays.toString(array));
        for (int i = 1; i < len; i++) {
            int leftIndex=i-1;
            int temp=array[i];
            //内部循环,将数组元素从小到大排序
            //一个一个相邻比较
            //此处leftIndex是>=0,如果没有等于第一个元素就不会被排序
            while(leftIndex>=0 && array[leftIndex]>temp){
                //左边元素右移，通过index--，不断进行相邻比较
                array[leftIndex+1]=array[leftIndex];
                leftIndex--;
            }
            //填补空位
            array[leftIndex+1]=temp;
        }
        System.out.println("排序之后数组的值为"+ Arrays.toString(array));
    }
}
程序输出结果如下：
排序之前数组的值为[88, 66, 25, 61]
排序之后数组的值为[25, 61, 66, 88]

Process finished with exit code 0