先说思路假设有一个数组是arr = [24, 69, 80, 57, 13]，分别对应的下标是[0, 1, 2, 3, 4]现在需要把最大的数字放在最后面，就排序成[13, 24, 57, 69, 80]，看样子非常简单。


那么进行第一次排序，24和69排序，下标0对应的是24，和下标1对应的69进行比较。

小的放在左边，大的放在右边，那么这里就不变，这里直接举例子80和57的位置。

80对应的下标是2，57对应的下标是3，现在80比57大所以需要把57变换到80的位置也就是下标变化。

所以需要做的就是把2的下标80变成57，3的下标57变成80就进行了一次交换。

然后就变成了80和13的交换，80比13大，首先80现在的下标是3，13的下标是4。

那么就需要把4的下标13变成80，3的下标80变成13就可以进行了交换，如下交换流程。

从左到右比较


第一轮比较：目标大的放在最后面

第一次比较[24, 69, 80, 57, 13]

第二次比较[24, 69, 80, 57, 13]

第三次比较[24,69,57,80,13]

第四次比较[24, 69, 57, 13, 80]


第二轮比较：目标把第二大的数放在倒数第二的位置

第一次比较[24, 69, 57, 13, 80]

第二次比较[24, 57, 69, 13, 80]

第三次比较[24, 57, 13, 69, 80]


第三轮比较：目标把第三大的数放在倒数第三的位置

第一次比较[24, 57, 13, 69, 80]

第二次比较[24, 13, 57, 69, 80]


第四轮比较：目标把第四大的数放在倒数第四的位置

第一次比较[13, 24, 57, 69, 80]


到这里可以发现进行了四轮比较，每一轮比较里面还有比较数字的操作，这里可以简单进行代码，如下图就实现了第一轮循环，输出是

24 69 57 13 80 ，如果我们需要进行第二轮比较只需要把循环的 j < 4变成 j < 3即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package chapter6.冒泡排序;

public class maopao {
    public static void main(String[] args) {
        int arr[] = {24, 69, 80, 57, 13};
        //定义temp变量
        int temp = 0;
        for (int j = 0; j < 4; j++) {
            //假设这里是第一次循环j为0那么就判断的是arr[0] > arr[1]
            //也就是判断24 > 69
            if (arr[j] > arr[j + 1]) {
                //进行转换操作，稍微看看还是能看懂的因为进行两个数字转换
                //需要用到变量
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        //输出每次交换过后的数字
        for (int j = 0; j < arr.length; j++) {
            System.out.print(arr[j] + "\t");
        }
        //每次输出完之后换行
        System.out.println();
    }
}

如果要实现第二轮就可以直接把第一轮的代码再复制一遍即可，但是太麻烦了，所以这里就需要用到二层循环，因为有四轮循环，所以代码如下，就已经实现了代码，但是现在需要把代码变活，万一数组变了怎么办。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package chapter6.冒泡排序;

public class maopao {
    public static void main(String[] args) {
        int arr[] = {24, 69, 80, 57, 13};
        //定义temp变量
        int temp = 0;
        //增加外层循环，因为有四轮循环所以循环四次
        for (int i = 0; i < 4; i++) {
            /*
            * 每次循环完成之后需要减去一个1
            * 因为第第一轮比较已经比较完成，也就是第一个最大的数已经出来了
            * 就需要第二个最大的数字，就所以减去一个1，但是第一次循环的时候
            * 时候不需要减去，所以就减去0即可
            *
            * */
            for (int j = 0; j < 4 - i; j++) {
                //假设这里是第一次循环j为0那么就判断的是arr[0] > arr[1]
                //也就是判断24 > 69
                if (arr[j] > arr[j + 1]) {
                    //进行转换操作，稍微看看还是能看懂的因为进行两个数字转换
                    //需要用到变量
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            //输出每次交换过后的数字
            for (int j = 0; j < arr.length; j++) {
                System.out.print(arr[j] + "\t");
            }
            //每次输出完之后换行
            System.out.println();
        }


    }
}

修改代码如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package chapter6.冒泡排序;

public class maopao {
    public static void main(String[] args) {
        int arr[] = {24, 69, 80, 57, 13};
        //定义temp变量
        int temp = 0;
        //增加外层循环，因为有四轮循环所以循环四次
        /*
        *       这里四次可以发现是数组长度减1
        * 可以把i < 4修改为 i < i < arr.length - 1
        *
        * */
        for (int i = 0; i < arr.length - 1; i++) {
            /*
            * 每次循环完成之后需要减去一个1
            * 因为第第一轮比较已经比较完成，也就是第一个最大的数已经出来了
            * 就需要第二个最大的数字，就所以减去一个1，但是第一次循环的时候
            * 时候不需要减去，所以就减去0即可
            *
            * */
            /*
            *       这里四次和上面一样
            *
            * */
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //假设这里是第一次循环j为0那么就判断的是arr[0] > arr[1]
                //也就是判断24 > 69
                if (arr[j] > arr[j + 1]) {
                    //进行转换操作，稍微看看还是能看懂的因为进行两个数字转换
                    //需要用到变量
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.print("======第"+(i + 1)+"轮比较======" + "\n");
            //输出每次交换过后的数字
            for (int j = 0; j < arr.length; j++) {
                System.out.print(arr[j] + "\t");
            }
            //每次输出完之后换行
            System.out.println();
        }


    }
}