Java 根据位计数按升序对数组排序

请告诉我，我应该做哪些更改，以按位升序对数组进行排序 考虑一个名为元素的n个十进制整数数组。我们希望根据以下规则重新排列元素：

按整数二进制表示形式中的1个数按升序对整数排序。例如，7→ 111和8→ 1000，那么8（二进制中只有一个1）将在7（二进制中有三个1）之前排序。 两个或多个整数在其二进制表示中具有相同数量的1，通过增加十进制值进行排序。例如，5→ 101和6→ 110在它们的二进制表示中都包含双1，因此5将在6之前排序，因为它的十进制值较小

我错在哪里？ 输入： 5. 5. 3. 7. 10 14 输出： 3. 5. 10 7. 十四,

代码：

import java.io.*；
导入java.util.*；
导入java.text.*；
导入java.math.*；
导入java.util.regex.*；
公共类测试员{
/**
*完成下面的功能。
*请勿修改此功能之外的任何内容！
*/
静态int[]重新排列（int[]元素）{
int[]aux=新的int[elements.length]；
INTA；
对于（int i=0；i>1；
} 
aux[i]=计数；
系统输出打印LN（辅助[i]）；
//系统输出println（元素[i]）；
}
//系统输出打印项次（辅助）；
//系统输出打印项次（元素）；
对于（int i=1；i<（elements.length）；i++）
{
//系统输出打印LN（辅助[i]）；
//系统输出println（元素[i]）；
//使用2个键，因为我们需要对这两个键进行排序
//同时排列
int key1=辅助[i]；
int key2=元素[i]；
int j=i-1；
/*移动arr[0..i-1]和aux[0..i-1]的元素，
使得aux[0..i-1]的元素
大于键1，前进一个位置
他们目前的处境如何*/
而（j>=0&&aux[j]>key1）
{
aux[j+1]=aux[j]；
元素[j+1]=元素[j]；
j=j-1；
}
辅助[j+1]=键1；
元素[j+1]=键2；
}
//系统输出打印项次（辅助）；
返回元素；
}
/**
*不要修改此方法！
*/
公共静态void main（字符串[]args）引发IOException{
扫描仪输入=新扫描仪（系统输入）；
int n=0；
n=Integer.parseInt（in.nextLine（）.trim（））；
int[]元素=新的int[n]；
int元素；
对于（int i=0；i

这是为感兴趣的人准备的C代码：

using System;

namespace ConsoleApp1
{
class Program
{
    static int[] rearrange(int[] elements)
    {
        Array.Sort(elements);

        int[] countOfOnesFromElements = new int[elements.Length];
        int currentElement;
        for (int i = 0; i < elements.Length; i++)
        {
            int countTheNumberOfOnes = 0;

            currentElement = elements[i];
            for (int k = 0; k < 32; k++)
            {
                if ((currentElement & 1) == 1)
                {
                    countTheNumberOfOnes++;
                }
                currentElement = currentElement >> 1;
            }

            countOfOnesFromElements[i] = countTheNumberOfOnes;
            Console.WriteLine(countOfOnesFromElements[i]);
        }
        for (int i = 1; i < (elements.Length); i++)
        {
            int key1 = countOfOnesFromElements[i];
            int key2 = elements[i];
            int j = i - 1;

            while (j >= 0 && countOfOnesFromElements[j] > key1)
            {
                countOfOnesFromElements[j + 1] = countOfOnesFromElements[j];
                elements[j + 1] = elements[j];
                j = j - 1;
            }
            countOfOnesFromElements[j + 1] = key1;
            elements[j + 1] = key2;
        }

        return elements;           
    }
    static void Main(string[] args)
    {
        int[] res;

        int _elements_size = 0;
        Console.WriteLine("Input the element size: ");
        _elements_size = Convert.ToInt32(Console.ReadLine());
        int[] _elements = new int[_elements_size];
        int _elements_item;

        for(int _elements_i = 0; _elements_i < _elements_size; _elements_i++)
        {
            Console.WriteLine("What is Element {0}? ", _elements_i);
            _elements_item = Convert.ToInt32(Console.ReadLine());
            _elements[_elements_i] = +_elements_item;
        }

        res = rearrange(_elements);
        Console.WriteLine("\r\nAll elements in order of binary");
        for(int res_i = 0; res_i < res.Length; res_i++)
        {
            Console.WriteLine(res[res_i]);               
        }
        Console.ReadLine();

    }
}

使用系统；
名称空间控制台EAPP1
{
班级计划
{
静态int[]重新排列（int[]元素）
{
数组。排序（元素）；
int[]countOfOnesFromElements=新int[elements.Length]；
int-currentElement；
for（int i=0；i>1；
}
CountOfOneFromElements[i]=CountOfOnes；
Console.WriteLine（countOfOnesFromElements[i]）；
}
对于（int i=1；i<（elements.Length）；i++）
{
int key1=元素[i]的计数；
int key2=元素[i]；
int j=i-1；
而（j>=0&&countOfOnesFromElements[j]>key1）
{
countOfOnesFromElements[j+1]=countOfOnesFromElements[j]；
元素[j+1]=元素[j]；
j=j-1；
}
countOfOnesFromElements[j+1]=key1；
元素[j+1]=键2；
}
返回元素；
}
静态void Main（字符串[]参数）
{
int[]res；
int _元素_大小=0；
WriteLine（“输入元素大小：”）；
_elements_size=Convert.ToInt32（Console.ReadLine（））；
int[]_elements=新的int[_elements_size]；
内部元素项；
对于（int\u elements\u i=0；\u elements\u i<\u elements\u size；\u elements\u i++）
{
WriteLine（“什么是元素{0}？”，_elements_i）；
_elements_item=Convert.ToInt32（Console.ReadLine（））；
_元素[\u元素\u i]=+\u元素\u项；
}
res=重新排列（_个元素）；
Console.WriteLine（“\r\n按二进制顺序排列的所有元素”）；
for（int res_i=0；res_i

}

这是为感兴趣的人准备的C代码：

using System;

namespace ConsoleApp1
{
class Program
{
    static int[] rearrange(int[] elements)
    {
        Array.Sort(elements);

        int[] countOfOnesFromElements = new int[elements.Length];
        int currentElement;
        for (int i = 0; i < elements.Length; i++)
        {
            int countTheNumberOfOnes = 0;

            currentElement = elements[i];
            for (int k = 0; k < 32; k++)
            {
                if ((currentElement & 1) == 1)
                {
                    countTheNumberOfOnes++;
                }
                currentElement = currentElement >> 1;
            }

            countOfOnesFromElements[i] = countTheNumberOfOnes;
            Console.WriteLine(countOfOnesFromElements[i]);
        }
        for (int i = 1; i < (elements.Length); i++)
        {
            int key1 = countOfOnesFromElements[i];
            int key2 = elements[i];
            int j = i - 1;

            while (j >= 0 && countOfOnesFromElements[j] > key1)
            {
                countOfOnesFromElements[j + 1] = countOfOnesFromElements[j];
                elements[j + 1] = elements[j];
                j = j - 1;
            }
            countOfOnesFromElements[j + 1] = key1;
            elements[j + 1] = key2;
        }

        return elements;           
    }
    static void Main(string[] args)
    {
        int[] res;

        int _elements_size = 0;
        Console.WriteLine("Input the element size: ");
        _elements_size = Convert.ToInt32(Console.ReadLine());
        int[] _elements = new int[_elements_size];
        int _elements_item;

        for(int _elements_i = 0; _elements_i < _elements_size; _elements_i++)
        {
            Console.WriteLine("What is Element {0}? ", _elements_i);
            _elements_item = Convert.ToInt32(Console.ReadLine());
            _elements[_elements_i] = +_elements_item;
        }

        res = rearrange(_elements);
        Console.WriteLine("\r\nAll elements in order of binary");
        for(int res_i = 0; res_i < res.Length; res_i++)
        {
            Console.WriteLine(res[res_i]);               
        }
        Console.ReadLine();

    }
}

使用系统；
名称空间控制台EAPP1
{
班级计划
{
静态int[]重新排列（int[]元素）
{
数组。排序（元素）；
int[]countOfOnesFromElements=新int[elements.Length]；
int-currentElement；
for（int i=0；i>1；
}
CountOfOneFromElements[i]=CountOfOnes；
Console.WriteLine（countOfOnesFromElements[i]）；
}
对于（int i=1；i<（elements.Length
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/*
 * Sort the integers in ascending order by the number of 1's in their binary
 * representations. For example, 7→ 111 and 8 → 1000, so 8 (which has single 1
 * in binary) would be ordered before 7 (which has triple 1's in binary). Two or
 * more integers having the same number of 1's in their binary representations
 * are ordered by increasing decimal value. For example, 5 → 101 and 6→ 110 both
 * contain double 1's in their binary representation, so 5 would be ordered
 * before 6 because it has the smaller decimal value.
 */

public class Solution {

public static void main(String[] args) {
    List<Integer> myList = new ArrayList<>();
    myList.add(5);
    myList.add(3);
    myList.add(5);
    myList.add(7);
    myList.add(10);
    myList.add(14);
    myList.add(6);      

    Solution s1 = new Solution();
    System.out.println("before: " + myList.toString());
    /*
     * for (Integer num : myList) { System.out.println("*** sNumber = " + num);
     * System.out.println("Binary = " + Integer.toBinaryString(num));
     * System.out.println("Number of one bits = " + Integer.bitCount(num)); }
     */
    System.out.println("after: " + s1.rearrangeList(myList).toString());

}

public List<Integer> rearrangeList(List<Integer> theList) {

    Collections.sort(theList, new Comparator<Integer>() {

        @Override
        public int compare(Integer num1, Integer num2) {
            /*
             * a negative integer, zero, or a positive integer as the first argument 
             * is less
             * than, equal to, or greater than the second.
             */
            int result = 0;
            if (num1 == num2) {
                result = 0;
            } else if (Integer.bitCount(num1) < Integer.bitCount(num2)) {// 5=101 and 
                                                                         // 7=111
                result = -1;
            } else if (Integer.bitCount(num1) > Integer.bitCount(num2)) {// 7=111 and 
                                                                         // 6=110
                result = 1;
            } else if (Integer.bitCount(num1) == Integer.bitCount(num2)) {// 5=101 
                                                                          // 10=1010
                result = (num1 < num2) ? -1 : 1;// sort in natural order
            }
            return result;
        }
    });

    return theList;
    }

}

public static List<Integer> rearrange(List<Integer> elements){
    if(elements == null) {
        return null;
    }
    Collections.sort(elements, new sortByBinaryRep());
    Set<Integer> set = new LinkedHashSet<>(elements);
    return new LinkedList<>(set);
}

import java.util.Comparator;

public class sortByBinaryRep implements Comparator<Integer> {

    @Override
    public int compare(Integer num1, Integer num2) {
        String binaryRep1 = Integer.toBinaryString(num1);
        String binaryRep2 = Integer.toBinaryString(num2);
        int bits1 = countBits(binaryRep1);
        int bits2 = countBits(binaryRep2);

        if(bits1 == bits2) {
            return num1 - num2;
        }
        else {
            return bits1 - bits2;
        }
    }

    private int countBits(String a){
        int count = 0;
        for(char c: a.toCharArray()) {
            if(c == '1') {
                count++;
            }
        }
        return count;
    }
}