本文主要是介绍Java基础笔记17——冒泡算法，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

冒泡算法：

升序(降序)：

（1）第一轮：

1.比较第一个数和第二个数，如果第一个数比第二个数大(小)，则交换两个数的位置；否则不变
2.比较第二个数和第三个数，如果第二个数比第三个数大(小)，则交换两个数的位置；否则不变
3.比较第三个数和第四个数，如果第三个数比第四个数大(小)，则交换两个数的位置；否则不变
4. 。。。。。。
5.比较第N-1个数和第N个数，如果第N-1个数比第N个数大(小)，则交换两个数的位置；否则不变
第一轮比较了N-1次，得到的最后一个数是数组中的最大(小)值

（2）第二轮：

1.比较第一个数和第二个数，如果第一个数比第二个数大(小)，则交换两个数的位置；否则不变
2.比较第二个数和第三个数，如果第二个数比第三个数大(小)，则交换两个数的位置；否则不变
3.比较第三个数和第四个数，如果第三个数比第四个数大(小)，则交换两个数的位置；否则不变
4. 。。。。。。
5.比较第N-2个数和第N-1个数，如果第N-2个数比第N-1个数大(小)，则交换两个数的位置；否则不变
第二轮比较了N-2次，得到的倒数第二个数是数组中的最二大(小)的值

（3）第三轮：

1.比较第一个数和第二个数，如果第一个数比第二个数大(小)，则交换两个数的位置；否则不变
2.比较第二个数和第三个数，如果第二个数比第三个数大(小)，则交换两个数的位置；否则不变
3.比较第三个数和第四个数，如果第三个数比第四个数大(小)，则交换两个数的位置；否则不变
4. 。。。。。。
5.比较第N-3个数和第N-2个数，如果第N-3个数比第N-2个数大(小)，则交换两个数的位置；否则不变
第二轮比较了N-3次，得到的倒数第三个数是数组中的最三大(小)的值

。。。。。。

（N-1）第N-1轮：

1.比较第一个数和第二个数，如果第一个数比第二个数大(小)，则交换两个数的位置；否则不变
第N-1轮比较了1次，冒泡算法结束

参考链接：十八经典排序算法：https://www.cnblogs.com/onepixel/articles/7674659.html

例子：

package com.lqh.chapter01;

import java.util.Arrays;

public class _15maopao {
    public static void main(String[] args) {
        int[] list = new int[] { 66, 33, 22, 11 };
        // 升序
        System.out.println("-----------升序-----------");
        for (int i = 1; i < list.length; i++) {// N-1轮比较
            System.out.println("第" + i + "轮比较之后得到：");
            for (int j = 0; j < list.length - i; j++) {
                if (list[j] > list[j + 1]) {
                    int temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                }
            }
            System.out.println(Arrays.toString(list));
        }
        

        System.out.println("-----------降序-----------");
        // 降序
        int[] list2 = new int[] { 22, 33, 44, 55, 66 };
        for (int i = 1; i < list2.length; i++) {
            System.out.println("第" + i + "轮比较之后得到：");
            for (int j = 0; j < list2.length - i; j++) {
                if (list2[j] < list2[j + 1]) {
                    int temp = list2[j + 1];
                    list2[j + 1] = list2[j];
                    list2[j] = temp;
                }
            }
            System.out.println(Arrays.toString(list2));
        }
    }
}

输出结果为：

-----------升序-----------
第1轮比较之后得到：
[33, 22, 11, 66]
第2轮比较之后得到：
[22, 11, 33, 66]
第3轮比较之后得到：
[11, 22, 33, 66]
-----------降序-----------
第1轮比较之后得到：
[33, 44, 55, 66, 22]
第2轮比较之后得到：
[44, 55, 66, 33, 22]
第3轮比较之后得到：
[55, 66, 44, 33, 22]
第4轮比较之后得到：
[66, 55, 44, 33, 22]

这篇关于Java基础笔记17——冒泡算法的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！