进阶Day2 排序算法 冒泡、选择、直接插入

public class SortClass {

    private int[] array = {23, 11, 7, 29, 33, 59, 8, 20, 9, 3, 2, 6, 10, 44, 83, 28, 5, 1, 0, 36};

//    private int[] array = {23, 11, 7, 29, 33, 59, 8, 20, 9, 3, 2, 6, 10, 44, 83, 28, 5, 1, 0, 36,23, 11, 7, 29, 33, 59, 8, 20, 9, 3, 2, 6, 10, 44, 83, 28, 5, 1, 0, 36,23, 11, 7, 29, 33, 59, 8, 20, 9, 3, 2, 6, 10, 44, 83, 28, 5, 1, 0, 36};

//    private int[] array = {23, 11, 7, 29, 33, 59, 8, 20, 9, 3, 2, 6, 10, 44, 83, 28, 5, 1, 0, 36,23, 11, 7, 29, 33, 59, 8, 20, 9, 3, 2, 6, 10, 44, 83, 28, 5, 1, 0, 36,23, 11, 7, 29, 33, 59, 8, 20, 9, 3, 2, 6, 10, 44, 83, 28, 5, 1, 0, 36,23, 11, 7, 29, 33, 59, 8, 20, 9, 3, 2, 6, 10, 44, 83, 28, 5, 1, 0, 36,23, 11, 7, 29, 33, 59, 8, 20, 9, 3, 2, 6, 10, 44, 83, 28, 5, 1, 0, 36,23, 11, 7, 29, 33, 59, 8, 20, 9, 3, 2, 6, 10, 44, 83, 28, 5, 1, 0, 36};

    /**
     * 冒泡排序示例代码    时间复杂度O（n²）
     * 数组长度20  需要循环190次，数据交替110次   长度为60 需要遍历1770次数据交替900次  长度为120 需要遍历7140次数据交替3510次
     *
     * 两两比较，如果后者比前者大则交换位置
     * 每遍历一圈最大的数就会冒到最后，则确定了本轮比较中的最大值放到最后不动
     * 循环1、2直至遍历完所有
     */
    public void bubbleSort(){
        System.out.println(array.length);
        int a = 0;  //记录循环次数
        int b = 0;  //记录数据移动次数
        for (int i = 0; i < array.length; i++) {

            //数组-1 是因为下方比较是当前后下一个比较 避免下标溢出
            // -i则是因为每执行遍历一次循环都能确保数组最后的一个数为最大 所以为减少时间复杂度 可以-i  此为冒泡排序， 不-i也可以实现排序，只是相对来说算法不算优，会有不必要的资源浪费
            for (int j = 0; j < array.length -i -1; j++) {
                a++;
                //if里面的代码 是逐个比较 将最大的数值放到数组最后
                if(array[j]>array[j+1]){   //升序排序 判断当前下标的值是否大于后面一个下标的值   如果需要降序排序  将此行的>改为<即可
                    b++;
                    int temp = array[j];   //将当前下标的值存入临时变量
                    array[j] = array[j+1];  //将当前下标 和 下一个下标替换位置
                    array[j+1] = temp;      //将刚才保存的临时变量 赋值给下个下标
                }
            }
        }
        System.out.println(a);  //循环次数
        System.out.println("b:"+b);  //数据移动次数
        System.out.println(Arrays.toString(array));  //打印数组
    }

    /**
     * 选择排序  时间复杂度O（n²），
     * 数组长度20  需要循环210次数据交替20次   长度为60 需要遍历1830次数据交替60次  长度为120 需要遍历7260次数据交替120次
     * 但是由于选择排序每轮比较只交换一次，所以实际性能要优于冒泡
     *
     */
    public void selectSort(){
        int a=0;  //记录循环次数
        for (int i = 0; i < array.length; i++) {
            int max = 0;  //用于记录当前循环中最大值的下标
            for (int j = 0; j < array.length -i; j++) {
                a++;
                if(array[max]<array[j]){  //判断存在的最大值 是否小于循环的当前值
                    max=j;   //将当前值的下标记为最大值
                }
            }
            // 依次找到最大的数和未被计算为最大值的最后一个下标交替位置
            int temp = array[array.length - i - 1];
            array[array.length - i - 1] = array[max];
            array[max] = temp;
        }
        System.out.println(a);
        System.out.println(Arrays.toString(array));  //打印数组
    }

    /**
     * 直接插入排序   时间复杂度O（n²）
     *数组长度20  需要循环123次数据交替130次   长度为60 需要遍历953次数据交替960次  长度为120 需要遍历3623次数据交替3630次
     */
    public void insertSort(){
        int a = 0;  //记录循环次数
        int b = 0;  //记录数据移动次数
        for (int i = 0; i < array.length; i++) {
            int temp = array[i];  //记录当前循环下标的数据为临时变量
            int j;

            for (j = i - 1; j >= 0; j--) {
                a++;
                if (temp < array[j]) {
                    b++;
                    array[j + 1] = array[j];   //和在前面已经遍历过的数字比较 若小于 则往后移
                } else {
                    break;
                }
            }
            b++;
            array[j + 1] = temp;   //如果 二层for循环的if是false则此处是将自己赋值为自己，如果进了if则是将被往后移的下标赋值为当前值
        }
        System.out.println(a);  //循环次数
        System.out.println("b:"+b);  //数据移动次数
        System.out.println(Arrays.toString(array));  //打印数组
    }

}

 

 

 

 

参考链接：  https://blog.csdn.net/sd09044901guic/article/details/80613053