冒泡排序（Bubble Sort）

冒泡排序（Bubble Sort）

原理：依次比较相邻的两个数，将值大的元素交换到右边。

　思路：

1. 第一趟：从最左边开始，依次比较相邻的两个数，将小的数放在左边，大的数放在右边。一共比较Ｎ－１次，结果是将最大的排在了最右边。
2. 第二趟：从最左边开始，依次比较相邻的两个数，将小的数放在左边，大的数放在右边。一共比较Ｎ－２次，结果是将第二大的数排在了倒数第二的位置。
3. 以此类推，一共进行了Ｎ－１趟。

举例说明：将数组：int[] arr = {4,3,9,7,6,1}

第一趟(5次)：

• 3 4 9 7 6 1
• 3 4 9 7 6 1
• 3 4 7 9 6 1
• 3 4 7 6 9 1
• 3 4 7 6 1 9

第二趟(4次)：

• 3 4 7 6 1 9
• 3 4 7 6 1 9
• 3 4 6 7 1 9
• 3 4 6 1 7 9

第三趟(3次)：

• 3 4 6 1 7 9
• 3 4 6 1 7 9
• 3 4 1 6 7 9

第四趟(2次)：

• 3 4 1 6 7 9
• 3 1 4 6 7 9

第五趟(1次)：

1 3 4 6 7 9

思路：分两层循环，外层循环控制进行了几趟，内层循环控制每趟进行了几次。共进行了N-1趟，第i趟进行了N-1-i次。（注意：i从0开始）

代码实现：

package com.woodpecker.czq;

public class Demo {
    public static void main(String[] args) {
        int[] arr = {4,3,9,7,6,1};
        //将数组的引用作为参数调用冒泡排序  
        bubbleSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    public static void bubbleSort(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length-1; i++) { //外层循环控制进行了几趟
            for (int j = 0; j < arr.length-1-i; j++) { //内层循环控制第i趟进行了几次
                if(arr[j] > arr[j+1]) {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

时间复杂度：O(n²)

优点：每进行一趟排序，比较就会少一次，稳定。易于理解。

缺点：时间复杂度太高，排序效率低。