图解Java经典算法冒泡选择插入希尔排序的原理与实现

public static void bubbleSort(int[] arr){
        //中间变量，用来交换数据
        int temp = 0;
        //外层循环
        for (int i = 0 ; i < arr.length - 1 ; i  ){
            //内层循环，每次找到最大的数后放在最后，下次遍历则会少一次，及arr.length - i - 1
            for(int j = 0; j < arr.length - i - 1; j  ){
                //判断大小
                if(arr[j] > arr[j   1]){
                    //将两数进行交换
                    temp = arr[j];
                    arr[j] = arr[j   1];
                    arr[j   1] = temp;
                }
            }
        }
}

public static void choiceSort(int[] arr){
        //用来记录最小的数
        int arrData = 0;
        //记录最小的数的下标
        int arrindx = 0;
        //外层循环，直到 arr.length - 1 即可
        for(int i = 0; i < arr.length - 1; i  ){
            //首先把arr[i] 当做最小的数，并记录下标
            arrData = arr[i];
            arrindx = i;
            //内层循环，遍历 i 以后的数，找到比 arr[i] 还小的数
            for (int j = i   1; j < arr.length; j  ){
                //找到更小的数，就进行记录
                if(arrData > arr[j]){
                    arrData = arr[j];
                    arrindx = j;
                }
            }
            //循环完毕，说明找到了，最小的数，与arr[i] 进行交换即可
            arr[arrindx] = arr[i];
            arr[i] = arrData;
        }
}

 public static void insertSort(int[] arr){
        //下标为 0 的数是确定的，从下标为 1 开始循环
        for (int i = 1; i < arr.length; i  ){
            // 将下标为 i 的数暂存起来
            int arrData = arr[i];
            //从 i - 1 开始往前循环
            int arrIndx = i - 1;
            //判断退出的条件 大于等于0
            while (arrIndx >= 0){
                //如果arrData 大于 下标为arrIndx 的数，则位置找到，退出循环
                if (arrData > arr[arrIndx]){
                    break;
                }
                //没有找到，就将前面的数往后移
                arr[arrIndx   1] = arr[arrIndx];
                arrIndx--;
            }
            //找到位置后，就将暂存的数据arrData 插入到下标为arrIndx的位置
            arr[arrIndx   1] = arrData;
        }
    }

    public static void shellSort_exchange(int[] arr){
        //做中间变量，进行数据交换
        int temp = 0;
        // g 首先数组总长除以2， 然后每次除以2
        for(int g = arr.length / 2 ; g > 0 ; g /= 2){
            // i 从 g 的位置开始遍历
            for(int i = g ; i < arr.length ; i  ){
                // j 从 i - g 的位置开始向前遍历，j 的位置由 j - g 来决定
                for(int j = i - g ; j >= 0 ; j -= g){
                    //判断 下标(j   g) 和 下标j 位置的数的大小，然后进行交换
                    if(arr[j   g] < arr[j]){
                        //交换即可
                        temp = arr[j   g];
                        arr[j   g] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
        }
    }

    public static void test1(int[] arr){
        //与前面一样，开始数组长度除以2 ， 然后每次除以2
        for(int g = arr.length / 2 ; g > 0 ; g /= 2){
            // i 从 g 位置开始，每次加一
            for(int i = g ; i < arr.length ; i  ){
                //定义 j 的位置 为 i
                int j = i ;
                //将 下标为 i 位置的数暂存起来
                int temp = arr[i];
                //判断 下标j位置的数 和 j - g 位置的数，与前面一样
                if(arr[j] < arr[j - g] ){
                    //遍历循环
                    while(j - g >= 0 && temp < arr[j - g]){
                        //满足条件，就移位，将前面的数 (下标j - g) 往后移 (下标j)
                        arr[j] = arr[j - g];
                        j -= g;// j 每次 -g
                    }
                }
                //退出循环或判断条件后，将暂存的temp (arr[i]) 赋值给 arr[j]
                arr[j] = temp;
            }
        }
    }