3011.力扣每日一题7/13 Java（冒泡排序）

• 博客主页：音符犹如代码
• 系列专栏：算法练习
• 关注博主，后期持续更新系列文章
• 如果有错误感谢请大家批评指出，及时修改
• 感谢大家点赞👍收藏⭐评论✍

目录

冒泡排序

解题思路

解题过程

时间复杂度

空间复杂度

---

冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法

基本思想：

它重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。

具体过程：

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

举例说明：

假设有一个数组 [5, 1, 4, 2, 8]
第一轮：

• 比较 5 和 1，交换得到 [1, 5, 4, 2, 8]
• 比较 5 和 4，交换得到 [1, 4, 5, 2, 8]
• 比较 5 和 2，交换得到 [1, 4, 2, 5, 8]
• 比较 5 和 8，不交换，第一轮结束，最大的数 8 已在末尾。

第二轮：

• 比较 1 和 4，不交换
• 比较 4 和 2，交换得到 [1, 2, 4, 5, 8]
• 比较 4 和 5，不交换，第二轮结束，第二大的数 5 已在正确位置。

第三轮：

• 比较 1 和 2，交换得到 [1, 2, 4, 5, 8]
• 比较 2 和 4，不交换，第三轮结束，第三大的数 4 已在正确位置。

第四轮：

• 比较 1 和 2，不交换，排序完成，得到 [1, 2, 4, 5, 8]

时间复杂度：

在最坏情况下，即数组完全逆序，需要进行 n - 1 轮比较，每轮比较 n - i - 1 次（i 是轮数），时间复杂度为 O(n²)在最好情况下，即数组已经有序，时间复杂度为 O(n)平均时间复杂度为 O(n²)

空间复杂度：

只在交换元素时使用了额外的临时变量，空间复杂度为 O(1)

冒泡排序总结：

冒泡排序的优点是实现简单，容易理解；缺点是效率较低，对于大规模数据排序不太适用

解题思路：

1. 首先，创建一个辅助数组 binaryCount 来存储每个数字的二进制中 1 的个数。
2. 然后，通过两层嵌套的循环，当相邻数字的二进制中 1 的个数相同时，如果它们的顺序不正确（前一个大于后一个），就进行交换。
3. 最后，检查经过交换操作后的数组是否有序，如果有序则返回 true，否则返回 false。

解题过程：

1. 计算每个数字二进制中 1 的个数并存入 binaryCount 数组。
2. 通过冒泡排序的思想，在相邻数字二进制 1 个数相同且顺序错误时进行交换。
3. 再次遍历数组检查是否有序。

时间复杂度

• 计算二进制中 1 的个数，遍历数组，时间复杂度为 O(n)
• 冒泡排序部分，最坏情况下，两层循环的时间复杂度为 O(n²)
• 最后检查数组是否有序，时间复杂度为 O(n)
  综合起来，总的时间复杂度为 O(n²)

空间复杂度

创建了一个辅助数组 binaryCount 来存储二进制中 1 的个数，空间复杂度为 O(n)

Code

class Solution {
    public boolean canSortArray(int[] nums) {
        int n = nums.length;
        int[] binaryCount = new int[n];

        for (int i = 0; i < n; i++) {
            binaryCount[i] = countSetBits(nums[i]);
        }

        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (binaryCount[j] == binaryCount[j + 1] && nums[j] > nums[j + 1]) {
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }

        for (int i = 0; i < n - 1; i++) {
            if (nums[i] > nums[i + 1]) {
                return false;
            }
        }

        return true;
    }

    public int countSetBits(int num) {
        int count = 0;
        while (num > 0) {
            if ((num & 1) == 1) {
                count++;
            }
            num >>= 1;
        }
        return count;
    }
}

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

哪里有阴影，哪里就有光——雨果（法国）