java数组中的冒泡排序

冒泡排序算法

1 每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。（冒出最大的那个气泡）

2 核心：

拿着左边的数字和右边的数字进行比对，当左边 > 右边的时候，交换位置。

3 冒泡排序

参与比较的数据 9 8 10 7 6 0 11

第一次循环：

8 9 10 7 6 0 11 （9和8进行比较：交换）

8 9 10 7 6 0 11 （9和10进行比较：不交换）

8 9 7 10 6 0 11 （10和7进行比较：交换）

8 9 7 6 10 0 11 （10和6进行比较：交换）

8 9 7 6 0 10 11 （10和0进行比较：交换）

8 9 7 6 0 10 11 （10和11进行比较：不交换）

最终冒泡的最大数据在右边：11

参与比较的数据：8 9 7 6 0 10

第二次循环：

8 9 7 6 0 10（8和9进行比较，不交换）

8 7 9 6 0 10（9和7进行比较，交换）

8 7 6 9 0 10（9和6进行比较，交换）

8 7 6 0 9 10（9和0进行比较，交换）

8 7 6 0 9 10（9和10进行比较，不交换）

参与比较的数据：8 7 6 0 9

第三次循环：

7 8 6 0 9（8和7进行比较，交换）

7 6 8 0 9（8和6进行比较，交换）

7 6 0 8 9（8和0进行比较，交换）

7 6 0 8 9（8和9进行比较，不交换）

参与比较的数据：7 6 0 8

第四次循环：

6 7 0 8（7和6进行比较，交换）

6 0 7 8（7和0进行比较，交换）

6 0 7 8（7和8进行比较，不交换）

参与比较的数据：6 0 7

第五次循环：

0 6 7（6和0进行比较，交换）

0 6 7（6和7进行比较，不交换）

参与比较的数据：0 6

第六次循环：

0 6（0和6进行比较，不交换）

冒泡排序代码：

package com.javaSe.Arrays;
/*
冒泡排序算法
1 每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。（冒出最大的那个气泡）
2 核心：
    拿着左边的数字和右边的数字进行比对，当左边 > 右边的时候，交换位置。

3 冒泡排序
    参与比较的数据 9 8 10 7 6 0 11
        第一次循环：
        8 9 10 7 6 0 11 （9和8进行比较：交换）
        8 9 10 7 6 0 11 （9和10进行比较：不交换）
        8 9 7 10 6 0 11 （10和7进行比较：交换）
        8 9 7 6 10 0 11 （10和6进行比较：交换）
        8 9 7 6 0 10 11 （10和0进行比较：交换）
        8 9 7 6 0 10 11 （10和11进行比较：不交换）
        最终冒泡的最大数据在右边：11
    
    参与比较的数据：8 9 7 6 0 10
        第二次循环：
        8 9 7 6 0 10（8和9进行比较，不交换）
        8 7 9 6 0 10（9和7进行比较，交换）
        8 7 6 9 0 10（9和6进行比较，交换）
        8 7 6 0 9 10（9和0进行比较，交换）
        8 7 6 0 9 10（9和10进行比较，不交换）
        
    参与比较的数据：8 7 6 0 9
        第三次循环：
        7 8 6 0 9（8和7进行比较，交换）
        7 6 8 0 9（8和6进行比较，交换）
        7 6 0 8 9（8和0进行比较，交换）
        7 6 0 8 9（8和9进行比较，不交换）
        
    参与比较的数据：7 6 0 8
        第四次循环：
        6 7 0 8（7和6进行比较，交换）
        6 0 7 8（7和0进行比较，交换）
        6 0 7 8（7和8进行比较，不交换）

    参与比较的数据：6 0 7
        第五次循环：
        0 6 7（6和0进行比较，交换）
        0 6 7（6和7进行比较，不交换）
        
    参与比较的数据：0 6
        第六次循环：
        0 6（0和6进行比较，不交换）
    
    
 */
public class BubbleSort {
    public static void main(String[] args) {
        // int类型数组对象
        int[] arr = {9,8,10,7,6,0,11};
        // 7条数据，循环6次。一下的代码可以循环6次。
        // for (int j = 0; j < i.length - 1; j++) {
        //      System.out.println(j);
        // }
    
        // 7条数据，循环6次。一下的代码可以循环6次。（冒泡排序的外层循环采用这种方式）
        // int count = 0;
        for (int i = arr.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                // count++;
                if (arr[j] > arr[j + 1]){
                    // 交换位置
                    // i[k] 和 i[k+1] 交换
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        
        // System.out.println("比较次数：" + count); //比较次数：21
        // 输出结果
        for (int k = 0; k < arr.length; k++) {
            System.out.print(arr[k] + " ");
        }
    }
}