[LeetCode] 1356. Sort Integers by The Number of 1 Bits

Given an integer array arr. You have to sort the integers in the array in ascending order by the number of 1's in their binary representation and in case of two or more integers have the same number of 1's you have to sort them in ascending order.

Return the sorted array.

Example 1:

Input: arr = [0,1,2,3,4,5,6,7,8]
Output: [0,1,2,4,8,3,5,6,7]
Explantion: [0] is the only integer with 0 bits.
[1,2,4,8] all have 1 bit.
[3,5,6] have 2 bits.
[7] has 3 bits.
The sorted array by bits is [0,1,2,4,8,3,5,6,7]

Example 2:

Input: arr = [1024,512,256,128,64,32,16,8,4,2,1]
Output: [1,2,4,8,16,32,64,128,256,512,1024]
Explantion: All integers have 1 bit in the binary representation, you should just sort them in ascending order.

Example 3:

Input: arr = [10000,10000]
Output: [10000,10000]

Example 4:

Input: arr = [2,3,5,7,11,13,17,19]
Output: [2,3,5,17,7,11,13,19]

Example 5:

Input: arr = [10,100,1000,10000]
Output: [10,100,10000,1000]

Constraints:

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

根据数字二进制下 1 的数目排序。

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

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

请你返回排序后的数组。

题意很简单，对于每个数字，我们计算其二进制表达中的 1 的个数，根据 1 出现的多少对数组进行排序。对于两个二进制表达中1的数量相同的数字，我们再按照其十进制的表达由大到小排序。

这道题不涉及算法，就是按这个规则实现排序即可。这里我提供两种实现。

第一种是利用 Java 中 Integer.bitCount 这个函数，计算每一个数字的二进制表达有多少个 1，把这个结果乘以 10000 再加这个数字本身。这样如果遇到两个数字他们的二进制表达中 1 的个数相同，此时我们也可以通过这两个数字本身的大小关系决定他们之间如何排序。注意代码第八行为什么要乘以10000，是因为input的范围最大也就到10000（引用）。

时间O(nlogn)

空间O(n)

Java实现

class Solution {
    public int[] sortByBits(int[] arr) {
        Integer[] a = new Integer[arr.length];
        for (int i = 0; i < a.length; i++) {
            a[i] = arr[i];
        }
        // Arrays.sort(a, (i, j) -> Integer.bitCount(i) != Integer.bitCount(j) ? Integer.bitCount(i) - Integer.bitCount(j) : i - j);
        Arrays.sort(a, Comparator.comparing(i -> Integer.bitCount(i) * 10000 + i));
        for (int i = 0; i < a.length; i++) {
            arr[i] = a[i];
        }
        return arr;
    }
}

 

第二种方法比第一种稍微简化一些，还是用 Integer.bitCount 比较每两个数字的二进制表达中 1 的个数，如果相同，则再根据数字本身大小排序。时间空间复杂度跟第一种方法一样。

Java实现

class Solution {
    public int[] sortByBits(int[] arr) {
        int n = arr.length;
        Integer[] nums = new Integer[n];
        for (int i = 0; i < n; i++) {
            nums[i] = arr[i];
        }

        Arrays.sort(nums, (a, b) -> Integer.bitCount(a) == Integer.bitCount(b) ? a - b : Integer.bitCount(a) - Integer.bitCount(b));
        for (int i = 0; i < n; i++) {
            arr[i] = nums[i];
        }
        return arr;
    }
}

 

LeetCode 题目总结