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

第一种方法
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);
        }
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值