详解冒泡排序算法原理与使用方法

冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历要排序的数列，每次比较相邻的两个元素，如果顺序不对则交换它们的位置。遍历数列的工作会重复地进行，每一轮会将最大的数排到最后，下一轮遍历时最后的数已经确定下来了，不需要再次比较。时间复杂度为 O(n^2)，是一种效率较低的排序算法，但是它简单易懂，容易实现，所以在小规模数据的排序中仍然被广泛使用。

冒泡排序的使用方法如下：

1. 首先定义一个数组，存储需要排序的数据。

int arr[] = {5, 3, 8, 4, 2};

1. 对数组进行遍历，比较相邻的两个元素并交换它们。

for(int i = 0; i < arr.length - 1; i++){
    for(int j = 0; j < arr.length - 1 - i; j++){
        if(arr[j] > arr[j + 1]){
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

1. 遍历完成后，数组中的数据已经排好序了。

示例 1：

假设有一个需要排序的数组 arr[] = {5, 3, 8, 4, 2}，冒泡排序的具体过程如下所示。

第一轮遍历时：
- 比较 5 和 3，由于 5 大于 3，所以交换它们的位置，此时数组变为 {3, 5, 8, 4, 2}。
- 比较 5 和 8，由于 5 小于 8，不需要交换位置。
- 比较 8 和 4，由于 8 大于 4，所以交换它们的位置，此时数组变为 {3, 5, 4, 8, 2}。
- 比较 8 和 2，由于 8 大于 2，所以交换它们的位置，此时数组变为 {3, 5, 4, 2, 8}。

第一轮遍历结束后，最大的数字 8 已经放在了数组的最后。

第二轮遍历时：
- 比较 3 和 5，由于 3 小于 5，不需要交换位置。
- 比较 5 和 4，由于 5 大于 4，所以交换它们的位置，此时数组变为 {3, 4, 5, 2, 8}。
- 比较 5 和 2，由于 5 大于 2，所以交换它们的位置，此时数组变为 {3, 4, 2, 5, 8}。

第二轮遍历结束后，第二大的数字 5 已经放在了数组的倒数第二个位置。

第三轮遍历时：
- 比较 3 和 4，由于 3 小于 4，不需要交换位置。
- 比较 4 和 2，由于 4 大于 2，所以交换它们的位置，此时数组变为 {3, 2, 4, 5, 8}。

第三轮遍历结束后，第三大的数字 4 已经放在了数组的倒数第三个位置。

第四轮遍历时：
- 比较 3 和 2，由于 3 大于 2，所以交换它们的位置，此时数组变为 {2, 3, 4, 5, 8}。

第四轮遍历结束后，第四大的数字 3 已经放在了数组的倒数第四个位置。

第五轮遍历时：
- 数组中只剩下一个数字了，不需要继续排序。

最终，数组变为 {2, 3, 4, 5, 8}，排序完成。

示例 2：

假设有一个需要排序的数组 arr[] = {1, 1, 0, 0, 1, 0, 1, 1, 0}，冒泡排序的具体过程如下所示。

第一轮遍历时：
- 比较 1 和 1，由于相等，不需要交换位置。
- 比较 1 和 0，由于 1 大于 0，所以交换它们的位置，此时数组变为 {1, 0, 1, 0, 1, 0, 1, 1, 0}。
- 比较 1 和 1，由于相等，不需要交换位置。
- 比较 1 和 0，由于 1 大于 0，所以交换它们的位置，此时数组变为 {1, 0, 1, 0, 1, 0, 1, 1, 0}。
- 比较 1 和 0，由于 1 大于 0，所以交换它们的位置，此时数组变为 {1, 0, 1, 0, 1, 0, 1, 1, 0}。
- 比较 0 和 1，由于 0 小于 1，不需要交换位置。
- 比较 1 和 1，由于相等，不需要交换位置。
- 比较 1 和 1，由于相等，不需要交换位置。

第一轮遍历结束后，最大的数字 1 已经放在了数组的最后。

第二轮遍历时：
- 比较 1 和 0，由于 1 大于 0，所以交换它们的位置，此时数组变为 {0, 1, 0, 1, 0, 1, 1, 0, 1}。
- 比较 1 和 0，由于 1 大于 0，所以交换它们的位置，此时数组变为 {0, 0, 1, 1, 0, 1, 1, 0, 1}。
- 比较 1 和 0，由于 1 大于 0，所以交换它们的位置，此时数组变为 {0, 0, 1, 0, 1, 1, 1, 0, 1}。
- 比较 1 和 1，由于相等，不需要交换位置。
- 比较 1 和 1，由于相等，不需要交换位置。

第二轮遍历结束后，第二大的数字 1 已经放在了数组的倒数第二个位置。

第三轮遍历时：
- 比较 0 和 1，由于 0 小于 1，不需要交换位置。
- 比较 1 和 0，由于 1 大于 0，所以交换它们的位置，此时数组变为 {0, 0, 0, 1, 1, 1, 1, 0, 1}。
- 比较 1 和 1，由于相等，不需要交换位置。

第三轮遍历结束后，第三大的数字 1 已经放在了数组的倒数第三个位置。

第四轮遍历时：
- 比较 0 和 0，由于相等，不需要交换位置。

第四轮遍历结束后，第四大的数字 0 已经放在了数组的倒数第四个位置。

第五轮遍历时：
- 比较 0 和 1，由于 0 小于 1，不需要交换位置。

第五轮遍历结束后，第五大的数字 0 已经放在了数组的倒数第五个位置。

第六轮遍历时：
- 比较 0 和 1，由于 0 小于 1，不需要交换位置。

第六轮遍历结束后，第六大的数字 0 已经放在了数组的倒数第六个位置。

第七轮遍历时：
- 比较 0 和 1，由于 0 小于 1，不需要交换位置。

第七轮遍历结束后，第七大的数字 0 已经放在了数组的倒数第七个位置。

第八轮遍历时：
- 比较 0 和 1，由于 0 小于 1，不需要交换位置。

第八轮遍历结束后，第八大的数字 0 已经放在了数组的倒数第八个位置。

第九轮遍历时：
- 数组中只剩下一个数字了，不需要继续排序。

最终，数组变为 {0, 0, 0, 1, 1, 1, 1, 1, 1}，排序完成。