冒泡循環_借鑒大神加自己的理解。

  第一種方法
    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);
            }
        }
    }