LeetCode 1356. 根据数字二进制下1的数目排序

题目描述

给你一个整数数组 arr 。请你将数组中的元素按照其二进制表示中数字 1 的数目升序排序。

如果存在多个数字二进制中 1 的数目相同，则必须将它们按照数值大小升序排列。

请你返回排序后的数组。

示例 1：

输入：arr = [0,1,2,3,4,5,6,7,8]

输出：[0,1,2,4,8,3,5,6,7]

解释：[0] 是唯一一个有 0 个 1 的数。

1,2,4,8\] 都有 1 个 1。 \[3,5,6\] 都有 2 个 1。 \[7\] 有 3 个 1。 按照 1 的个数排序得到的结果数组为 \[0,1,2,4,8,3,5,6,7

示例 2：

输入：arr = [1024,512,256,128,64,32,16,8,4,2,1]

输出：[1,2,4,8,16,32,64,128,256,512,1024]

解释：数组中所有整数二进制下都只有 1 个 1，所以它们按照数值大小升序排列。

提示：

1 <= arr.length <= 500
0 <= arr[i] <= 10^4

解题思路

本题的核心是多关键字排序：

第一关键字：数字二进制表示中 1 的个数（升序）
第二关键字：数字本身的大小（升序）

C++ 中，我们可以利用 pair 天然的排序特性，将每个数字的 (1的个数, 原数字) 作为一个 pair 存入数组，然后对整个数组排序，最后提取原数字即可。

如何统计二进制中 1 的个数？

方法一（代码中使用）：循环检查低 16 位（题目给定数字范围 ≤ 10^4，低 16 位足够），通过右移和按位与 &1 统计 1 的个数。
方法二：使用 C++ 内置函数 __builtin_popcount，直接返回整数二进制中 1 的个数，更加简洁高效。

排序规则

pair 在 C++ 中默认按照 first 升序，若 first 相等则按照 second 升序。这完全符合题目要求。

代码实现

版本一：手动统计 + pair 排序

cpp 复制代码

class Solution {
public:
    vector<int> sortByBits(vector<int>& arr) {
        vector<int> res;                  // 存储最终结果
        vector<pair<int,int>> v;           // 存储 (1的个数, 原数字) 对

        for (int i = 0; i < arr.size(); i++) {
            int cnt = 0;
            // 统计 arr[i] 的二进制中 1 的个数（检查低 16 位）
            for (int j = 0; j < 16; j++) {
                if (arr[i] >> j & 1)       // 右移 j 位后与 1 相与，判断该位是否为 1
                    cnt++;
            }
            v.push_back({cnt, arr[i]});    // 存入配对
        }

        sort(v.begin(), v.end());           // 排序，默认按 pair 的第一、第二元素升序

        for (int i = 0; i < v.size(); i++)
            res.push_back(v[i].second);     // 提取排序后的原数字

        return res;
    }
};

版本二：使用内置函数 + 自定义排序（原地修改，更简洁）

cpp 复制代码

class Solution {
public:
    vector<int> sortByBits(vector<int>& arr) {
        sort(arr.begin(), arr.end(), [](int a, int b) {
            int ca = __builtin_popcount(a);
            int cb = __builtin_popcount(b);
            // 先按 1 的个数升序，个数相同按数值升序
            return ca == cb ? a < b : ca < cb;
        });
        return arr;
    }
};

复杂度分析

时间复杂度 ：

统计每个数字的 1 的个数耗时 O(位数)（版本一中位数为 16，可视为 O(1)），排序耗时 O(n log n)，总体 O(n log n)。

版本二同样为 O(n log n)，但代码更简洁。
空间复杂度 ：

版本一需要额外的 O(n) 空间存储配对数组；版本二原地排序，只需 O(1) 额外空间（不计递归栈）。

总结

本题是典型的"根据某个变换后的值排序"问题，关键在于将"二进制中 1 的个数"作为排序关键字。

可以使用 pair 将关键字和原值绑定，利用默认排序规则完成多关键字排序。
也可以直接在自定义比较函数中计算 1 的个数，实现原地排序。
对于统计二进制中 1 的个数，内置函数 __builtin_popcount 是最高效的选择（编译器会优化为一条 CPU 指令）。