算法冲刺

---

1. 冒泡排序

代码实现

/**
 * @ClassName : BubbleSortFinal  
 * @Description :  冒泡排序：O（n^2）
 * @Author : Yemulin  
 * @Date : 2020/09/02 01:56  
 * @Version : 1.0
 */

public class BubbleSortFinal {

    //测试部分
    public static void main(String[] args) {
        //创建一个长度为10的数组
        int[] arr = new int[10];
        for (int i = 0; i < 10; i++) {
            arr[i] = (int) (Math.random() * 1000);
        }

        System.out.println(Arrays.toString(arr));
        bubbleSortFinal(arr);
        System.out.println(Arrays.toString(arr));
    }

    //冒泡排序
    public static void bubbleSortFinal(int[] arr) {
        int temp = 0;
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (flag == false) {
                break;
            } else {
                flag = false;
            }
        }
    }
}

思路：

public class BubbleSort {

    public static void main(String[] args) {

//        int[] arr = {3, 9, -1, 10, -2};
//        //为了容易理解，将冒泡排序的演变过程进行展示
//
//        System.out.println("排序前：");
//        System.out.println(Arrays.toString(arr));

        //测试一下冒泡排序的速度O(n^2),给80000个数据，测试
        //创建要给80000个的随机数组
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000);
        }

        long timeMillis1 = System.currentTimeMillis();
        System.out.println("排序前：" + timeMillis1);
        //测试冒泡排序
        bubbleSort(arr);

        long timeMillis2 = System.currentTimeMillis();
        System.out.println("排序后：" + timeMillis2);
        System.out.println("所需时间：" + (timeMillis2 - timeMillis1) + "毫秒");
//        System.out.println(Arrays.toString(arr));
        /*//冒泡排序时间复杂度：O(n^2)
        int temp = 0; //临时变量
        boolean flag = false; //标识变量，表示是否进行过交换
        for (int i = 0; i < arr.length - 1; i++) {

            for (int j = 0; j < arr.length - 1 - i; j++) {
                //如果前面的数比后面的数大，则交换
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }

            System.out.println("第" + (i + 1) + "次排序后的数组");
            System.out.println(Arrays.toString(arr));

            if (!flag) { //此处即等同于“flag == false”
                break;
            } else {
                flag = false;
            }
        }*/


/*        //第二趟排序，就是将第二大的数排在倒数第二位
        for (int j = 0; j < arr.length - 1 - 1; j++) {
            //如果前面的数比后面的数大，则交换
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }

        System.out.println("第二次排序后的数组");
        System.out.println(Arrays.toString(arr));

        //第三趟排序，就是将第三大的数排在倒数第三位
        for (int j = 0; j < arr.length - 1 - 2; j++) {
            //如果前面的数比后面的数大，则交换
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }

        System.out.println("第三次排序后的数组");
        System.out.println(Arrays.toString(arr));


        //第四趟排序，就是将第四大的数排在倒数第四位
        for (int j = 0; j < arr.length - 1 - 3; j++) {
            //如果前面的数比后面的数大，则交换
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }

        System.out.println("第四次排序后的数组");
        System.out.println(Arrays.toString(arr));*/
    }

    //将前面的冒泡排序算法，封装成一个方法
    public static void bubbleSort(int[] arr) {

        //冒泡排序时间复杂度：O(n^2)
        int temp = 0; //临时变量
        boolean flag = false; //标识变量，表示是否进行过交换
        for (int i = 0; i < arr.length - 1; i++) {

            for (int j = 0; j < arr.length - 1 - i; j++) {
                //如果前面的数比后面的数大，则交换
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }

//            System.out.println("第" + (i + 1) + "次排序后的数组");
//            System.out.println(Arrays.toString(arr));

            if (!flag) { //此处即等同于“flag == false”
                break;
            } else {
                flag = false;
            }
        }
    }
}

2. 选择排序

代码实现

/**
 * @ClassName : SelectSortFinal  
 * @Description :  
 * @Author : Yemulin  
 * @Date : 2020/09/02 03:23  
 * @Version : 1.0
 */
//测试部分
public class SelectSortFinal {

    public static void main(String[] args) {
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 800000);
        }

        System.out.println("排序前");
//        System.out.println(Arrays.toString(arr));
        long millis1 = System.currentTimeMillis();
        System.out.println(millis1);

        selectSortFinal(arr);

        System.out.println("排序后");
//        System.out.println(Arrays.toString(arr));
        long millis2 = System.currentTimeMillis();
        System.out.println(millis2);
        System.out.println("所需时间为:" + (millis2-millis1));
    }

//选择排序
    public static void selectSortFinal(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length - 1; j++) {
                if (min > arr[j]) { //说明假定的最小值，并不是最小
                    min = arr[j]; //重置min
                    minIndex = j; //重置minIndex
                }
            }

            //如果minIndex不等于i了, 证明发生了交换, 之前的预测最小值是arr[i]是错误的
            //所以要交换i与j的值了
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
    }
}

思路：

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        System.out.println("排序前");
        System.out.println(Arrays.toString(arr));
        selectSort(arr);
        System.out.println("排序后");
        System.out.println(Arrays.toString(arr));
    }

    //选择排序
    public static void selectSort(int[] arr) {

        //在推导的过程中,我们发现了很多规律, 因此, 可以使用for来解决
        for (int i = 0; i < arr.length -1 ; i++) {

            int minIndex = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) { //说明假定的最小值，并不是最小
                    min = arr[j]; //重置min
                    minIndex = j; //重置minIndex
                }
            }

            //将最小值,放在arr[0],即交换
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }

//            System.out.println("第"+ i+1 +"轮后~~");
//            System.out.println(Arrays.toString(arr));//1, 34, 119, 101
        }


        //使用逐步推导的方式来，讲解选择排序
        //第一轮
        //原始的数组： 101 ，34 ， 119 ， 1
        //第一轮排序： 1 ， 34 ， 119 ， 101
        //算法 先简单--》再复杂

 /*       //第一轮
        int minIndex = 0;
        int min = arr[0];
        for (int j = 0 + 1; j < arr.length; j++) {
            if (min > arr[j]) { //说明假定的最小值，并不是最小
                min = arr[j]; //重置min
                minIndex = j; //重置minIndex
            }
        }

        //将最小值,放在arr[0],即交换
        if (minIndex != 0) {
            arr[minIndex] = arr[0];
            arr[0] = min;
        }

        System.out.println("第一轮后~~");
        System.out.println(Arrays.toString(arr));//1, 34, 119, 101

        //第二轮
        minIndex = 1;
        min = arr[1];
        for (int j = 1 + 1; j < arr.length; j++) {
            if (min > arr[j]) { //说明假定的最小值，并不是最小
                min = arr[j]; //重置min
                minIndex = j; //重置minIndex
            }
        }

        //将最小值,放在arr[0],即交换
        if (minIndex != 1) {
            arr[minIndex] = arr[1];
            arr[1] = min;

        }

        System.out.println("第二轮后~~");
        System.out.println(Arrays.toString(arr));//1, 34, 119, 101

        //第三轮
        minIndex = 2;
        min = arr[2];
        for (int j = 2 + 1; j < arr.length; j++) {
            if (min > arr[j]) { //说明假定的最小值，并不是最小
                min = arr[j]; //重置min
                minIndex = j; //重置minIndex
            }
        }

        //将最小值,放在arr[0],即交换
        if (minIndex != 2) {
            arr[minIndex] = arr[2];
            arr[2] = min;

        }

        System.out.println("第三轮后~~");
        System.out.println(Arrays.toString(arr));//1, 34, 101, 119*/
    }
}