冒泡循环_借鉴大神加自己的理解。

Posted 2020-12-26 binlicheng

  第一种方法
    public static void maoPao() {

        int[] arr = { 6, 3, 8, 2, 9, 1 };
        System.out.println("排序前数组为：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        for (int i = 0; i < arr.length - 1; i++) {// 外层循环控制排序趟数 ，因为6个数，只需要循环5次就行。所以减1
            for (int j = 0; j < arr.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次

                //外圈循环：arr.length - 1 
                  //例如长度为6；说明是6个数进行比较，因此只需要比较5次就可以了。

                //内圈循环：arr.length - 1 - i
                // 减 1： 因为下面是 (arr[j] > arr[j + 1]  比较，如果不减1，
                //当j最大的时候，arr[j + 1] 就会报错，超出数组长度

                 //减  i  :  例如当 i = 1时，说明第一次循环结束，刚开始第二次外循环，
                  //经过第一次循环之后，最后一个数就是最大的，
                //没有必要每次循环都在此进行和最后一个最大的比较的。

                 //比较原理
                  //相邻的两两比较。
                 // 例如：内循环开始时， j=0；arr[j]  和   arr[j+1]  就是  
                  //arr[0]  和  arr[1]  比较，如果  arr[0]  大于  arr[1]  就让两个数的值互换，
                  //arr【0】获得数值较小值，arr【1】获得较大的值。当内循环开始第二次，j=1，
                   //arr【0】就不再比较，arr【1】和arr【2】
                  // 比较，直到最大值到最后一位。然后再次开始外循环，获得第二小的最大值。直到结束。
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        System.out.println();
        System.out.println("排序后的数组为：");
        for (int num : arr) {
            System.out.print(num + " ");
        }

    }


第二种方法

public static void maoPao2() {

        int[] unsorted = { 6, 3, 8, 2, 9, 1 };
        System.out.println("排序前数组为：");
        for (int num : unsorted) {
            System.out.print(num + " ");
        }
        System.out.println(unsorted.length);
        for (int i = 0; i < unsorted.length - 1; i++) {
            // 当j=i；说明先比较第一个，第一个比较完成之后，后面的循环就不在比较了。

            // 当i=0；unsorted[i]就是unsorted[0]，说明这是第一次循环，
            //  把unsorted[0]和unsorted[j]（j从1一直变化到最大值）

            // 期间unsorted[0]依次和它们比较，如果unsorted[0]大于其中一个就相互换值
             // ，直到unsorted[0]是最小的
            // 当第二次循环开始的时候，i=1；内循环直接放弃unsorted[0]的比较，
             //直接从unsorted[1]开始和unsorted[j]开始进行比较，然后确定第二小的值
            // 直到循环结束，从小到大
            for (int j = i; j < unsorted.length; j++) {

                if (unsorted[i] > unsorted[j+1]) {

                    int temp = unsorted[i];
                    unsorted[i] = unsorted[j+1];
                    unsorted[j+1] = temp;
                }
            }
        }

        System.out.println();
        System.out.println("排序后的数组为：");
        for (int num : unsorted) {
            System.out.print(num + " ");
        }

    }


第三种方法
//前面两个方法都是先获得最大的数放在最后，然后获得第二小的数。
 //这个方法是先获得最小的数，然后依次获得第二小的数。
private void core(int[] array) {

        int arrayLength = array.length;

        for (int i = 0; i < arrayLength; i++) {
            for (int j = arrayLength - 2; j >= i; j--) {
                if (array[j] > array[j + 1]) {
                    ArrayUtils.swap(array, j, j + 1);
                }
            }
        }
    }


第四种方法（双向冒泡排序）

说明：从一个数组的开头和结尾同时开始排序，当到中间时结束。
同时获得最大的数和最小的数，分别放在开始和结尾。然后获得第二
小的数和第二大的数放在第二位和倒数第二位，直到中间碰头。

private void core(int[] array) {
        int arrayLength = array.length;

        int preIndex = 0;
        int backIndex = arrayLength - 1;
        while(preIndex < backIndex) {
            preSort(array, arrayLength, preIndex);
            preIndex++;

            if (preIndex >= backIndex) {
                break;
            }

            backSort(array, backIndex);
            backIndex--;
        }
    }

    // 从前向后排序
    private void preSort(int[] array, int length, int preIndex) {
        for (int i = preIndex + 1; i < length; i++) {
            if (array[preIndex] > array[i]) {
                ArrayUtils.swap(array, preIndex, i);
            }
        }
    }

    // 从后向前排序
    private void backSort(int[] array, int backIndex) {
        for (int i = backIndex - 1; i >= 0; i--) {
            if (array[i] > array[backIndex]) {
                ArrayUtils.swap(array, i, backIndex);
            }
        }
    }