初识冒泡排序

本文介绍了冒泡排序的基本原理,通过一个具体的例子展示了如何将一组数字从小到大排序。冒泡排序包括两个方法,即默认正序排序和自定义顺序排序。文章还深入分析了冒泡排序的时间复杂度,指出在最坏情况下,时间复杂度为O(n^2)。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

将{6,5,4,3,2,1}从小到排序
冒泡排序原理:
1.相邻两个元素做比较,如果前一个元素比后一个元素大,则交换两个元素的位置
2.每对相邻的的两个元素做同样的工作,从开始的第一个元素到结尾的最后一个元素,最终最后一个位置的元素就是最大的
3.在原数据的基础上,第一次冒泡最大的到最后一位,
在第一次冒泡的基础上,也就是6可以不参加运算,第二次冒泡第二大的到倒数第二位
在第二次冒泡的基础上,也就是5,6可以不参加运算,第三次冒泡第三大的到倒数第三位
在第三次冒泡的基础上,也就是4,5,6可以不参加运算,第四次冒泡第四大的到倒数第四位。。。。。。依次类推

在这里插入图片描述
Api设计

Bubble中包含2个方法,默认正序sort(Comparable[] arr)和自定义顺序sort(T[] arr,Comparator comparator)

public class Bubble {

    public static void main(String[] args) {
        Integer arr[] = {5,6,  4, 3, 2, 1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
        sort(arr,Comparator.reverseOrder());
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 自定义排序
     * @param arr
     * @param comparator
     * @param <T>
     */
    public static <T> void sort(T[] arr,Comparator<T> comparator) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (greater(comparator,arr[j],arr[j+1])) {
                    exch(arr, j, j + 1);
                }
            }
        }
    }




    /**
     * 正序
     * @param arr
     * @param <T>
     */
    public static <T> void sort(Comparable<T>[] arr) {
        //有多少个元素参与冒泡 i开始角标 arr.length - 1长度比最大角标小1,没有等于是因为最后一个元素后面没有相邻元素了,最后一个元素在比较元素大小的时候的j+1角标体现
        for (int i = 0; i < arr.length - 1; i++) {
            //每次循环都减少一个元素
            for (int j = 0; j < arr.length - 1 - i; j++) {
            //相邻连个元素比较
                if (greater(arr[j], arr[j + 1])) {
                    exch(arr, j, j + 1);
                }
            }
        }
    }

    /**
     * 比较大小,如果c1比c2大,返回true,否则false,正序
     *
     * @param c1
     * @param c2
     * @return
     */
    private static boolean greater(Comparable c1, Comparable c2) {
        return c1.compareTo(c2) > 0 ? Boolean.TRUE : Boolean.FALSE;
    }

    private static <T> boolean greater(Comparator comparator,T c1, T c2) {
        return comparator.compare(c1,c2) > 0 ? Boolean.TRUE : Boolean.FALSE;
    }

    /**
     * 将arr数组中i角标和j角标位置互换
     *
     * @param arr 数组
     * @param i   角标
     * @param j   角标
     * @param <T>
     */
    private static <T> void exch(T[] arr, int i, int j) {
        T temp;
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;

    }

}

时间复杂度分析
冒泡排序使用了双层for,其中内存循环的循环体是真正完成排序的代码,所以我们分析冒泡排序的时间复杂度,主要分析一下内层循环的执行次数即可

在最坏的情况下,也就是相邻连个元素每次都需要交换

元素的比较次数为
(n-1)+(n-2)+(n-3)+…+3+2+1=n^2/2-n/2

公式推导
设pn=(n-1)+(n-2)+(n-3)+…+3+2+1
设sn=1+2+3+…+(n-3)+(n-2)+(n-1)
pn+sn=(n-1+1)+(n-2+2)+(n-3+3)+…+(3+n-3)+(2+n-2)+(1+n-1)
因为一共有n-1个数,所以
pn+sn=n(n-1)
因为pn=sn,所以
pn=(n(n-1))/2

元素的交换次数为
(n-1)+(n-2)+(n-3)+…+3+2+1=n^2/2-n/2

总执行次数为

2(n^2/2-n/2)=n^2-n

根据大O推导法则,去掉最高项的常数因子,去掉常数项,所以时间复杂度为O(n^2)

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值