好程序员Java学习路线分享冒泡排序及优化

​ 好程序员Java学习路线分享冒泡排序及优化,冒泡排序是一定典型的交换排序,如排序规则是升序,有如下数列:

 

  A[0] A[1] A[2] A[3] ...... A[n]

 

​ 将A[0]和A[1]比较,如果A[0]>A[1] ,则交换两个元素的位置,否则不变, 再继续比较A[1]和A[2],直到A[n-1]和A[n]。即比较相邻的两个元素,如果前一个大,就交换(否则不交换),再继续比较后面的元素,每一轮比较之后,最大的元素会移动到最后(完成一轮冒泡);再开始第二轮冒泡,本次会选出第二大的元素。重复冒泡的过程,直到没有相邻的元素需要交换,则排序完成,像碳酸饮料中的气泡,故而称为冒泡排序。

 

   

 

简化过程,设置一个简单的数组,在编程中,元素的索引从0开始:

 

[5, 3, 1, 4, 2]

 

```

    int[] nums = {5, 3, 1, 4, 2};

    //要比较n次,n是数组中数字的个数

    for (int i = 0; i < nums.length; i++) {

        //比较j和j+1位置的元素,每比较完一次,最大的元素会移动到末尾

        for (int j = 0; j < nums.length - 1; j++) {

            if (nums[j] > nums[j + 1]) {

                int temp = nums[j + 1];

                nums[j + 1] = nums[j];

                nums[j] = temp;

            }

        }

    }

```

 

第一轮比较,经过这一轮比较,最大的元素在末尾

 

[<font color="red">5, 3</font>, 1, 4, 2] 比较第0和1个元素 ,**交换** [<font color="red">3, 5</font>, 1, 4, 2]<br/>

[3,<font color="red"> 5, 1</font>, 4, 2] 比较第1和2个元素 ,**交换** [3, <font color="red">1, 5</font>, 4, 2]<br/>

[3, 1, <font color="red">5, 4</font>, 2] 比较第2和3个元素 ,**交换** [3,1, <font color="red"> 4, 5</font>, 2]<br/>

[3, 1, 4, <font color="red">5, 2</font>] 比较第3和4个元素 ,**交换** [3, 1, 4, <font color="red">2, 5</font>] 最大的元素在末尾<br/>

 

第二轮比较,经过这轮比较,最大的两个元素在末尾

 

[<font color="red">3, 1</font>, 4, 2, 5] 比较第0和1个元素 ,**交换** [<font color="red">1, 3</font>, 4, 2, 5]<br/>

[1, <font color="red">3, 4</font>, 2, 5] 比较第1和2个元素 ,不动 [1, <font color="red">3, 4</font>, 2, 5]<br/>

[1, 3, <font color="red">4, 2</font>, 5] 比较第2和3个元素 ,**交换** [1, 3, <font color="red">2, 4</font>, 5]<br/>

[1, 3, 2, <font color="red">4, 5</font>] 比较第3和4个元素 ,不动 [1, 3, 2, <font color="red">4, 5</font>]  这次比较是多余的,因为第1轮过后,最大的元素在末尾<br/>

 

第三轮比较,经过这轮比较,最大的三个元素在末尾

 

[<font color="red">1, 3</font>, 2, 4, 5] 比较第0和1个元素 ,不动 [<font color="red">1, 3</font>, 2, 4, 5]<br/>

[1, <font color="red">3, 2</font>, 4, 5] 比较第1和2个元素 ,**交换** [1, <font color="red">2, 3</font>, 4, 5]<br/>

[1, 2,<font color="red"> 3, 4</font>, 5] 比较第2和3个元素 ,不动 [1, 2, <font color="red">3, 4</font>, 5]  这次比较多余的<br/>

[1, 2, 3, <font color="red">4, 5</font>] 比较第3和4个元素 ,不动 [1, 2, 3, <font color="red">4, 5</font>]  这次比较是多余的<br/>

 

第四轮比较,经过这轮比较,最大的四个元素在末尾

 

[<font color="red">1, 2</font>, 3, 4, 5] 比较第0和1个元素 ,不动 [<font color="red">1, 2</font>, 3, 4, 5]<br/>

[1, <font color="red">2, 3</font>, 4, 5] 比较第1和2个元素 ,不动 [1, <font color="red">2, 3</font>, 4, 5]  这次比较是多余的<br/>

[1, 2,<font color="red"> 3, 4</font>, 5] 比较第2和3个元素 ,不动 [1, 2, <font color="red">3, 4</font>, 5]  这次比较是多余的<br/>

[1, 2, 3, <font color="red">4, 5</font>] 比较第3和4个元素 ,不动 [1, 2, 3, <font color="red">4, 5</font>]  这次比较是多余的<br/>

 

第五轮比较,经过这轮比较,排序完成

 

[<font color="red">1, 2</font>, 3, 4, 5] 比较第0和1个元素 ,不动 [<font color="red">1, 2</font>, 3, 4, 5]  这次比较是多余的<br/>

[1, <font color="red">2, 3</font>, 4, 5] 比较第1和2个元素 ,不动 [1, <font color="red">2, 3</font>, 4, 5]  这次比较是多余的<br/>

[1, 2, <font color="red">3, 4</font>, 5] 比较第2和3个元素 ,不动 [1, 2, <font color="red">3, 4</font>, 5]  这次比较是多余的<br/>

[1, 2, 3, <font color="red">4, 5</font>] 比较第3和4个元素 ,不动 [1, 2, 3, <font color="red">4, 5</font>]  这次比较是多余的<br/>

 

 

 

可以看到冒泡排序每次都从头比较,比较到末尾,但实际

 

第一轮比较后,最后1个数是最大的,下一轮不需要参与比较

 

第二轮比较后,最后2个数是最大的,下一轮不需要参与比较

 

第三轮比较后,最后3个数是最大的...

 

所以第n轮比较的时候,可以排除掉末尾已经排序好的元素,即末尾n-1个元素

 

```java

int[] nums = {5, 3, 1, 4, 2};

        //要比较n次,n是数组中数字的个数

        for (int i = 0; i < nums.length; i++) {

            //比较j和j+1位置的元素,每比较完一次,最大的元素会移动到末尾

            //最后i个元素不参与本次比较

            for (int j = 0; j < nums.length - 1 - i; j++) {

                if (nums[j] > nums[j + 1]) {

                    int temp = nums[j + 1];

                    nums[j + 1] = nums[j];

                    nums[j] = temp;

                }

            }

        }

```

 

运行结果:

 

第一轮比较,经过这一轮比较,最大的元素在末尾

 

[<font color="red">5, 3</font>, 1, 4, 2] 比较第0和1个元素 ,**交换** [<font color="red">3, 5</font>, 1, 4, 2]<br/>

[3,<font color="red"> 5, 1</font>, 4, 2] 比较第1和2个元素 ,**交换** [3, <font color="red">1, 5</font>, 4, 2]<br/>

[3, 1, <font color="red">5, 4</font>, 2] 比较第2和3个元素 ,**交换** [3,1, <font color="red"> 4, 5</font>, 2]<br/>

[3, 1, 4, <font color="red">5, 2</font>] 比较第3和4个元素 ,**交换** [3, 1, 4, <font color="red">2, 5</font>] 最大的元素在末尾<br/>

 

第二轮比较,经过这轮比较,最大的两个元素在末尾

 

[<font color="red">3, 1</font>, 4, 2, 5] 比较第0和1个元素 ,**交换** [<font color="red">1, 3</font>, 4, 2, 5]<br/>

[1, <font color="red">3, 4</font>, 2, 5] 比较第1和2个元素 ,不动 [1, <font color="red">3, 4</font>, 2, 5]<br/>

[1, 3, <font color="red">4, 2</font>, 5] 比较第2和3个元素 ,**交换** [1, 3, <font color="red">2, 4</font>, 5]<br/>

 

第三轮比较,经过这轮比较,最大的三个元素在末尾

 

[<font color="red">1, 3</font>, 2, 4, 5] 比较第0和1个元素 ,不动 [<font color="red">1, 3</font>, 2, 4, 5]<br/>

[1, <font color="red">3, 2</font>, 4, 5] 比较第1和2个元素 ,**交换** [1, <font color="red">2, 3</font>, 4, 5]<br/>

 

第四轮比较,经过这轮比较,最大的四个元素在末尾

 

[<font color="red">1, 2</font>, 3, 4, 5] 比较第0和1个元素 ,不动 [<font color="red">1, 2</font>, 3, 4, 5]<br/>

 

上面的算法,可以减少重复比较的次数,比较的次数是固定的。但如果本来数组中的元素就相对有序,则会出现如下状况:

 

初始数组是:[3, 1, 2, 4, 5]

 

第一轮

 

[<font color="red">3, 1</font>, 2, 4, 5]比较第0和1个元素,交换[<font color="red">1, 3</font>, 2, 4, 5]<br/>

[1,<font color="red"> 3, 2</font>, 4, 5]比较第1和2个元素,交换[1, <font color="red">2, 3</font>, 4, 5]<br/>

[1, <font color="red">2, 3</font>, 4, 5]比较第2和3个元素,不动[1, 2, <font color="red">3, 4</font>, 5]<br/>

[1, 2, <font color="red">3, 4</font>, 5]比较第3和4个元素,不动[1, 2, 3, <font color="red">4, 5</font>]<br/>

 

第二轮

 

[<font color="red">1, 2</font>, 3, 4, 5]比较第0和1个元素,不动[<font color="red">1, 2</font>, 3, 4, 5]<br/>

[1, <font color="red">2, 3</font>, 4, 5]比较第1和2个元素,不动[1, <font color="red">2, 3</font>, 4, 5]<br/>

[1, 2, <font color="red">3, 4</font>, 5]比较第2和3个元素,不动[1, 2, <font color="red">3, 4</font>, 5]<br/>

 

第三轮

 

[<font color="red">1, 2</font>, 3, 4, 5]比较第0和1个元素,不动[<font color="red">1, 2</font>, 3, 4, 5]<br/>

[1,<font color="red">2, 3</font>, 4, 5]比较第1和2个元素,不动[1, <font color="red">2, 3</font>, 4, 5]<br/>

 

第四轮

 

[<font color="red">1, 2</font>, 3, 4, 5]比较第0和1个元素,不动[1, 2, <font color="red">3, 4</font>, 5]<br/>

 

实际上数组中的元素,开始的时候只有数字3的位置需要移动,其它元素相对都是有序的。当3移动完成后,其它的元素不需要一定。所以在第二轮发现没有任何元素交换之后,就表示排序已经完成,第三轮和第四轮是多余的。

 

对于冒泡排序的优化,如果某一轮比较中没有发生任何交换,则代表排序已经完成,不需要再进行排序了:

 

```java

        int[] nums = {3, 1, 2, 4, 5};

        boolean flag;//是否交换的标志

        //要比较n次,n是数组中数字的个数

        for (int i = 0; i < nums.length; i++) {

            // 每次遍历标志位都要先置为false,才能判断后面的元素是否发生了交换

            flag = false;

            //比较j和j+1位置的元素,每比较完一次,最大的元素会移动到末尾

            //最后i个元素不参与本次比较

            for (int j = 0; j < nums.length - 1 - i; j++) {

                if (nums[j] > nums[j + 1]) {

                    int temp = nums[j + 1];

                    nums[j + 1] = nums[j];

                    nums[j] = temp;

                    flag = true;    //表示本轮发生了交换

                }

            }

            // 如果为false,代表本轮没有交换,元素已经有序

            if(!flag) break;

        }

    }

```

 

初始数组是:[3, 1, 2, 4, 5]

 

第一轮

 

[<font color="red">3, 1</font>, 2, 4, 5]比较第0和1个元素,交换[<font color="red">1, 3</font>, 2, 4, 5]<br/>

[1,<font color="red"> 3, 2</font>, 4, 5]比较第1和2个元素,交换[1, <font color="red">2, 3</font>, 4, 5]<br/>

[1, <font color="red">2, 3</font>, 4, 5]比较第2和3个元素,不动[1, 2, <font color="red">3, 4</font>, 5]<br/>

[1, 2, <font color="red">3, 4</font>, 5]比较第3和4个元素,不动[1, 2, 3, <font color="red">4, 5</font>]<br/>

 

第二轮

 

[<font color="red">1, 2</font>, 3, 4, 5]比较第0和1个元素,不动[<font color="red">1, 2</font>, 3, 4, 5]<br/>

[1, <font color="red">2, 3</font>, 4, 5]比较第1和2个元素,不动[1, <font color="red">2, 3</font>, 4, 5]<br/>

[1, 2, <font color="red">3, 4</font>, 5]比较第2和3个元素,不动[1, 2, <font color="red">3, 4</font>, 5]<br/>

 

在上面的排序中,3是最后一个移动的元素。3之后的元素都是有序的。所以只要比较3之前的元素即可。最后一次发生交换的元素,它后面的元素都是有序的,不需要再参与比较

 

```java

int[] nums = {3, 1, 2, 4, 5};

        boolean flag;//是否交换的标志

        int lastExchangeIndex =0;//最后一次交换的位置

        int sortBorder = nums.length - 1;

        //要比较n次,n是数组中数字的个数

        for (int i = 0; i < nums.length; i++) {

            // 每次遍历标志位都要先置为false,才能判断后面的元素是否发生了交换

            flag = false;

            //比较j和j+1位置的元素,每比较完一次,最大的元素会移动到末尾

            //最后i个元素不参与本次比较

            for (int j = 0; j < sortBorder ; j++) {

                if (nums[j] > nums[j + 1]) {

                    int temp = nums[j + 1];

                    nums[j + 1] = nums[j];

                    nums[j] = temp;

                    flag = true;    //表示本轮发生了交换

                    lastExchangeIndex =j;//记录最后一次发生交换的位置

                }

            }

            // 如果为false,代表本轮没有交换,元素已经有序

            sortBorder = lastExchangeIndex;

            if(!flag) break;

        }

 

```

 

运行结果:

 

第一轮

 

[<font color="red">3, 1</font>, 2, 4, 5]比较第0和1个元素,交换[<font color="red">1, 3</font>, 2, 4, 5]<br/>

[1,<font color="red"> 3, 2</font>, 4, 5]比较第1和2个元素,交换[1, <font color="red">2, 3</font>, 4, 5]<br/>

[1, <font color="red">2, 3</font>, 4, 5]比较第2和3个元素,不动[1, 2, <font color="red">3, 4</font>, 5]<br/>

[1, 2, <font color="red">3, 4</font>, 5]比较第3和4个元素,不动[1, 2, 3, <font color="red">4, 5</font>]<br/>

 

第二轮

 

[<font color="red">1, 2</font>, 3, 4, 5]比较第0和1个元素,不动[<font color="red">1, 2</font>, 3, 4, 5]

内容概要:本文详细探讨了智慧医疗建设的历程、现状、挑战及未来发展趋势。智慧医疗建设经历了信息化、数字化和数智化三个阶段,政策、需求和技术是其发展的三大推动力。文章指出,当前智慧医疗已从数据收集与治理阶段迈向数据价值应用阶段,特别是在高质量数据库建设、云计算、人工智能等技术的推动下,实现了临床科研、药物研发、真实世界研究及数字营销等多个场景的商业化落地。此外,文中还分析了医疗信息化系统同质化、数据孤岛、互联互通等痛点,并提出了云化转型、新产品、新技术和新服务作为突破方向。最后,通过奈特瑞、医渡科技、东软集团三个企业案例,展示了不同企业在智慧医疗领域的创新实践。 适合人群:医疗信息化从业者、医疗行业研究人员、医疗机构管理者、医疗科技企业相关人员、政策制定者及对智慧医疗感兴趣的投资者。 使用场景及目标:①了解智慧医疗建设的阶段性特征和发展趋势;②掌握医疗信息化建设中的关键技术和应用场景;③探讨解决医疗信息化系统同质化、数据孤岛等问题的策略;④学习企业如何通过新产品、新技术和新服务实现突破,推动智慧医疗发展。 其他说明:本文通过对智慧医疗建设的深入剖析,强调了政策导向、技术创新和市场需求的重要性,为企业和政策制定者提供了宝贵的参考。同时,文章也揭示了未来智慧医疗发展的广阔前景,特别是在数据资产化和数智化应用方面的巨大潜力。阅读时应注意结合政策背景和技术发展趋势,关注行业动态和企业创新实践。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值