按每个整数中1位的数目对数组中的整数进行排序

如何解决按每个整数中1位的数目对数组中的整数进行排序

给出一个整数数组arr。您必须按照二进制表示形式中数字1的升序对数组中的整数进行排序，如果两个或多个整数具有相同的1数，则必须按升序对它们进行排序。

返回排序后的数组。

输入：arr = [0,1,2,3,4,5,6,7,8]
输出：[0,8,7]
外植：[0]是唯一具有0位的整数。 [1,8]共有1 一点。 [3,6]有2位。 [7]有3位。按位排序的数组是 [0,7]

输入：arr = [1024,512,256,128,64,32,16,1]
输出： [1,1024]
外植：所有整数都有1 二进制表示形式中的位，则应将其排序 升序。

因此，我在这里使用Brian Kernigham的算法来计算数组中每个整数中1位的数目。到目前为止，这就是我编写的代码：-

class Solution {
public:
    vector<int> sortByBits(vector<int>& arr) {
        //firstly sort the input array
        sort(arr.begin(),arr.end());
        
        
        vector<int> count;
        //Using Brian Kernigham's Algorithm
        for(int i =0; i<arr.size(); i++){
            while(arr[i]){
                arr[i] = arr[i] & (arr[i] -1);
                count[i] ++;
            }
        } 
    }
};

但是，我不知道如何结合count[]数组和输入数组arr[]来获取输出。我曾考虑使用C ++的map() STL，但是由于该函数需要返回vector<int>，因此我放弃了。

有人可以提供进一步的解决方案吗？另外，请勿共享任何使用预定义功能builtin_popcount()

的代码

解决方法

最简单（但不是最有效）的方法是将数字和计数一起存储在容器中，对其进行排序，然后提取数字：

class Solution {
public:
    vector<int> sortByBits(vector<int>& arr) {
        vector<std::pair<int,int> temp;
        
        for(int i =0; i<arr.size(); i++){
            int count = 0;
            while(arr[i]){
                arr[i] = arr[i] & (arr[i] -1);
                count++;
            }
            temp.emplace_back(count,arr[i]);
        } 
       
        std::sort(temp.begin(),temp.end());   

        // extract the numbers again:
        std::vector<int> numbers;
        // ...
        return numbers;
    }
};

std::sort不稳定，因此，如果先对数字进行排序，然后再对设置的位数进行排序，则必须使用std::stable_sort。另一方面，std::pair<int,int>确实有一个operator<，可以与std::sort一起使用，以根据first然后是second进行排序。

或者，您可以编写一个比较器，让您对数字进行排序。这样不会像上面那样具有所有不必要的复制，但是它将调用该函数以对位数进行必要的计数：

class Solution {
public:
    vector<int> sortByBits(vector<int>& arr) {
       std::sort(arr.begin(),arr.end(),[](int a,int b) {
               // count bits here
               auto n_bits_a = count_bits(a);
               auto n_bits_b = count_bits(b);
               if (n_bits_a == n_bits_b) return a < b;
               return n_bits_a < n_bits_b; });
        return arr;
    }
};

如果再次使用std::pair<int,int>已经具有所需顺序的事实，则比较器可以写得更紧凑：

std::sort(arr.begin(),int b) {
    auto proj = [](int x) { return std::pair<int,int>{ count_bits(x),x}; };
    return proj(a) < proj(b);
});  

目前尚不清楚，为什么函数通过引用获取向量，而返回向量。上面还对参数进行了排序。

,

这是使用std::bitset的解决方案，它使处理位变得更加容易。 std::bitset有一个count()函数，该函数返回设置为1的位数，您可以在提供std::sort()的比较器函数中使用此函数：

#include <bitset>
#include <algorithm>
#include <vector>

class Solution {
public:
    std::vector<int> sortByBits(std::vector<int>& arr) {
        std::vector<int> vec = arr;

        std::sort(vec.begin(),vec.end(),int b) { 
                std::bitset<32> ba(a);
                std::bitset<32> bb(b);
                if (ba.count() == bb.count())
                    return a < b;
                else
                    return ba.count() < bb.count();
            });

        return vec;
    }
    
};

这里是Demo。