java中的经典算法：冒泡排序算法

$. 可以理解成当你静止一杯可乐时，里面的CO2随着你的静止,由于不不易溶于水的性质，

　　　　且会以气泡的形式逐渐向上漂浮。越大的气泡上浮速度越快。

冒泡排序算法的原理于此相似。 每次进行相邻值之间的替换；

　　　　大的值（元素）排在小的值（元素）前面  ，或者小的值（元素） 排在大的值（元素）前面。

 

import java.util.Arrays;

/*
* 冒泡排序算法
* */
public class BubbleSort {

    public static void main(String[] args) {

        int[] arr = {1, 35, 64, 24, 7, 6, 8, 46, 3, 34}; //定义10个数
        for (int i = 0; i < arr.length - 1; i++) {  //控制多少次循环
            System.out.println("循环次数："+i);
            for (int j = 0; j < arr.length - i - 1; j++) {//每进行一次循环排序的次数
                if (arr[j] > arr[j + 1]) {     //替换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
                System.out.println("排序次数："+ j);
            }
        }
        for (int num:arr){
            System.out.println(Arrays.asList(num));  //采用集合的方式更直观的看结果
        }

    }
}

外层for控制着循环次数，内层for控制每次循环所需要的排序次数。

共进行8次循环，每次排序的次数以此递减。

 

　　　　第九次因为只有一个元素无需排序，所以直接输出结果。所以只存在8次循环排序。

 

　　　　每循环一次排序当前相邻数大小关系。

 if (arr[j] > arr[j + 1]) {     //替换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }

　　使用temp相当于一个中介寄存。

传递方式如下：

在冒泡排序中，相邻大的元素（小的元素）替换小的元素（大的元素）。

下图为第一次排序的一个步骤。 

arr[0] < arr[1]不做变化

arr[1] < arr[2]:不做变化

arr[2] > arr[3]：替换

替换后的当前arr[2] = 24  arr[3] = 64

arr[3] > arr[4] : 替换

替换后的arr[3] = 7  arr[4] = 64

以此类推，大的值（元素）往前调，小的值（元素）往后调。

当循环到最后一次时，只有一个数，所以最后一次不需要循环， 所以 

i < arr.length - 1

 每循环一次一次进行排序时总是去除上次最后一个值，所以

j < arr.length - i - 1

 

版权声明：本文为CllOVER原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/CllOVER/p/10585955.html