Skip to content
Related Articles

Related Articles

Sort an array according to count of set bits
  • Difficulty Level : Medium
  • Last Updated : 09 Mar, 2021
GeeksforGeeks - Summer Carnival Banner

Given an array of positive integers, sort the array in decreasing order of count of set bits in binary representations of array elements. For integers having the same number of set bits in their binary representation, sort according to their position in the original array i.e., a stable sort. For example, if the input array is {3, 5}, then the output array should also be {3, 5}. Note that both 3 and 5 have the same number set bits.

Examples:

Input: arr[] = {5, 2, 3, 9, 4, 6, 7, 15, 32};
Output: 15 7 5 3 9 6 2 4 32
Explanation:
The integers in their binary representation are:
    15 -1111
    7  -0111
    5  -0101
    3  -0011
    9  -1001
    6  -0110
    2  -0010
    4- -0100
    32 -10000
hence the non-increasing sorted order is:
{15}, {7}, {5, 3, 9, 6}, {2, 4, 32}

Input: arr[] = {1, 2, 3, 4, 5, 6};
Output: 3 5 6 1 2 4
Explanation:
    3  - 0011
    5  - 0101
    6  - 0110
    1  - 0001
    2  - 0010
    4  - 0100
hence the non-increasing sorted order is
{3, 5, 6}, {1, 2, 4}

Method 1: Simple

  1. Create an auxiliary array and store the set-bit counts of all integers in the aux array
  2. Simultaneously sort both arrays according to the non-increasing order of auxiliary array. (Note that we need to use a stable sort algorithm)
Before sort:
int arr[] = {1, 2, 3, 4, 5, 6};
int aux[] = {1, 1, 2, 1, 2, 2}
After sort:
arr = {3, 5, 6, 1, 2, 4}
aux = {2, 2, 2, 1, 1, 1}

Implementation:

C++




// C++ program to implement simple approach to sort
// an array according to count of set bits.
#include <iostream>
 
using namespace std;
 
// a utility function that returns total set bits
// count in an integer
int countBits(int a)
{
    int count = 0;
    while (a)
    {
        if (a & 1 )
            count+= 1;
        a = a>>1;
    }
    return count;
}
 
// Function to simultaneously sort both arrays
// using insertion sort
void insertionSort(int arr[],int aux[], int n)
{
    for (int i = 1; i < n; i++)
    {
        // use 2 keys because we need to sort both
        // arrays simultaneously
        int key1 = aux[i];
        int key2 = arr[i];
        int j = i-1;
 
        /* Move elements of arr[0..i-1] and aux[0..i-1],
           such that elements of aux[0..i-1] are
           greater than key1, to one position ahead
           of their current position */
        while (j >= 0 && aux[j] < key1)
        {
            aux[j+1] = aux[j];
            arr[j+1] = arr[j];
            j = j-1;
        }
        aux[j+1] = key1;
        arr[j+1] = key2;
    }
}
 
// Function to sort according to bit count using
// an auxiliary array
void sortBySetBitCount(int arr[],int n)
{
    // Create an array and store count of
    // set bits in it.
    int aux[n];
    for (int i=0; i<n; i++)
        aux[i] = countBits(arr[i]);
 
    // Sort arr[] according to values in aux[]
    insertionSort(arr, aux, n);
}
 
// Utility function to print an array
void printArr(int arr[], int n)
{
    for (int i=0; i<n; i++)
        cout << arr[i] << " ";
}
 
// Driver Code
int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6};
    int n = sizeof(arr)/sizeof(arr[0]);
    sortBySetBitCount(arr, n);
    printArr(arr, n);
    return 0;
}

Java




// Java program to implement
// simple approach to sort
// an array according to
// count of set bits.
import java.io.*;
 
class GFG
{
 
// a utility function that
// returns total set bits
// count in an integer
static int countBits(int a)
{
    int count = 0;
    while (a > 0)
    {
        if ((a & 1) > 0)
            count+= 1;
        a = a >> 1;
    }
    return count;
}
 
// Function to simultaneously
// sort both arrays using
// insertion sort
static void insertionSort(int arr[],
                          int aux[], int n)
{
    for (int i = 1; i < n; i++)
    {
        // use 2 keys because we
        // need to sort both
        // arrays simultaneously
        int key1 = aux[i];
        int key2 = arr[i];
        int j = i - 1;
 
        /* Move elements of arr[0..i-1]
        and aux[0..i-1], such that
        elements of aux[0..i-1] are
        greater than key1, to one
        position ahead of their current
        position */
        while (j >= 0 && aux[j] < key1)
        {
            aux[j + 1] = aux[j];
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        aux[j + 1] = key1;
        arr[j + 1] = key2;
    }
}
 
// Function to sort according
// to bit count using an
// auxiliary array
static void sortBySetBitCount(int arr[],
                              int n)
{
    // Create an array and
    // store count of
    // set bits in it.
    int aux[] = new int[n];
    for (int i = 0; i < n; i++)
        aux[i] = countBits(arr[i]);
 
    // Sort arr[] according
    // to values in aux[]
    insertionSort(arr, aux, n);
}
 
// Utility function
// to print an array
static void printArr(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        System.out.print(arr[i] + " ");
}
 
// Driver Code
public static void main (String[] args)
{
    int arr[] = {1, 2, 3, 4, 5, 6};
    int n = arr.length;
    sortBySetBitCount(arr, n);
    printArr(arr, n);
}
}
 
// This code is contributed by anuj_67.

Python3




# Python 3 program to implement simple approach to sort
# an array according to count of set bits.
 
# a utility function that returns total set bits
# count in an integer
def countBits(a):
    count = 0
    while (a):
        if (a & 1):
            count+= 1
        a = a>>1
 
    return count
 
# Function to simultaneously sort both arrays
# using insertion sort
# ( http:#quiz.geeksforgeeks.org/insertion-sort/ )
def insertionSort(arr,aux, n):
    for i in range(1,n,1):
        # use 2 keys because we need to sort both
        # arrays simultaneously
        key1 = aux[i]
        key2 = arr[i]
        j = i-1
 
        # Move elements of arr[0..i-1] and aux[0..i-1],
        #  such that elements of aux[0..i-1] are
        # greater than key1, to one position ahead
        #  of their current position */
        while (j >= 0 and aux[j] < key1):
            aux[j+1] = aux[j]
            arr[j+1] = arr[j]
            j = j-1
 
        aux[j+1] = key1
        arr[j+1] = key2
 
# Function to sort according to bit count using
# an auxiliary array
def sortBySetBitCount(arr, n):
    # Create an array and store count of
    # set bits in it.
    aux = [0 for i in range(n)]
    for i in range(0,n,1):
        aux[i] = countBits(arr[i])
 
    # Sort arr[] according to values in aux[]
    insertionSort(arr, aux, n)
 
# Utility function to print an array
def printArr(arr, n):
    for i in range(0,n,1):
        print(arr[i],end = " ")
 
# Driver Code
if __name__ =='__main__':
    arr = [1, 2, 3, 4, 5, 6]
    n = len(arr)
    sortBySetBitCount(arr, n)
    printArr(arr, n)
 
# This code is contributed by
# Surendra_Gangwar

C#




// C# program to implement
// simple approach to sort
// an array according to
// count of set bits.
using System;
public class GFG
{
 
  // a utility function that
  // returns total set bits
  // count in an integer
  static int countBits(int a)
  {
    int count = 0;
    while (a > 0)
    {
      if ((a & 1) > 0)
        count += 1;
      a = a >> 1;
    }
    return count;
  }
 
  // Function to simultaneously
  // sort both arrays using
  // insertion sort
  // Function to simultaneously
  // sort both arrays using
  // insertion sort
  static void insertionSort(int []arr,
                            int []aux, int n)
  {
    for (int i = 1; i < n; i++)
    {
 
      // use 2 keys because we
      // need to sort both
      // arrays simultaneously
      int key1 = aux[i];
      int key2 = arr[i];
      int j = i - 1;
 
      /* Move elements of arr[0..i-1]
        and aux[0..i-1], such that
        elements of aux[0..i-1] are
        greater than key1, to one
        position ahead of their current
        position */
      while (j >= 0 && aux[j] < key1)
      {
        aux[j + 1] = aux[j];
        arr[j + 1] = arr[j];
        j = j - 1;
      }
      aux[j + 1] = key1;
      arr[j + 1] = key2;
    }
  }
 
  // Function to sort according
  // to bit count using an
  // auxiliary array
  static void sortBySetBitCount(int []arr,
                                int n)
  {
 
    // Create an array and
    // store count of
    // set bits in it.
    int []aux = new int[n];
    for (int i = 0; i < n; i++)
      aux[i] = countBits(arr[i]);
 
    // Sort arr[] according
    // to values in aux[]
    insertionSort(arr, aux, n);
  }
 
  // Utility function
  // to print an array
  static void printArr(int []arr, int n)
  {
    for (int i = 0; i < n; i++)
      Console.Write(arr[i] + " ");
  }
 
  // Driver Code
  static public void Main ()
  {
    int []arr = {1, 2, 3, 4, 5, 6};
    int n = arr.Length;
    sortBySetBitCount(arr, n);
    printArr(arr, n);
  }
}
 
// This code is contributed by divyeshrabadiya07.

Output:



3 5 6 1 2 4

Auxiliary Space: O(n)
Time complexity: O(n2)
Note: Time complexity can be improved to O(nLogn) by using a stable O(nlogn) sorting algorithm.

Method 2: Using std::sort()

Using custom comparator of std::sort to sort the array according to set-bit count

C++




// C++ program to sort an array according to
// count of set bits using std::sort()
#include <bits/stdc++.h>
 
using namespace std;
 
// a utility function that returns total set bits
// count in an integer
int countBits(int a)
{
    int count = 0;
    while (a) {
        if (a & 1)
            count += 1;
        a = a >> 1;
    }
    return count;
}
 
// custom comparator of std::sort
int cmp(int a, int b)
{
    int count1 = countBits(a);
    int count2 = countBits(b);
 
    // this takes care of the stability of
    // sorting algorithm too
    if (count1 <= count2)
        return false;
    return true;
}
 
// Function to sort according to bit count using
// std::sort
void sortBySetBitCount(int arr[], int n)
{
    stable_sort(arr, arr + n, cmp);
}
 
// Utility function to print an array
void printArr(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
    sortBySetBitCount(arr, n);
    printArr(arr, n);
    return 0;
}

Java




// Java program to sort an array according to
// count of set bits using std::sort()
import java.util.Arrays;
import java.util.Comparator;
 
public class Test {
 
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        Integer arr[] = { 1, 2, 3, 4, 5, 6 };
        int n = 6;
        sortBySetBitCount(arr, n);
        printArr(arr, n);
        System.out.println();
    }
 
    private static void printArr(Integer[] arr, int n)
    {
        // TODO Auto-generated method stub
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
        // cout << arr[i] << " ";
    }
 
    private static Integer[] sortBySetBitCount(
        Integer[] arr, int n)
    {
        // TODO Auto-generated method stub
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer arg0, Integer arg1)
            {
                // TODO Auto-generated method stub
                int c1 = Integer.bitCount(arg0);
                int c2 = Integer.bitCount(arg1);
                if (c1 <= c2)
                    return 1;
                else
                    return -1;
            }
        });
        return arr;
    }
}
 
// This code is contributed by 4-Bit-R

Python3




# Using custom comparator lambda function
arr = [1, 2, 3, 4, 5, 6]
 
 
# form a tuple with val, index
n = len(arr)
arr = [(arr[i], i) for i in range(n)]
 
 
def countSetBits(val):
    cnt = 0
    while val:
        cnt += val % 2
        val = val//2
    return cnt
 
 
# first criteria to sort is number of set bits,
# then the index
sorted_arr = sorted(arr, key=lambda val: (
    countSetBits(val[0]), n-val[1]), reverse=True)
sorted_arr = [val[0] for val in sorted_arr]
print(sorted_arr)

Output:

3 5 6 1 2 4

Auxiliary Space : O(1)
Time complexity : O(n log n)

Method 3 : Counting Sort based

This problem can be solved in O(n) time. The idea is similar to counting sort.
Note: There can be a minimum 1 set-bit and only a maximum of 31set-bits in an integer.
Steps (assuming that an integer takes 32 bits):

  1. Create a vector “count” of size 32. Each cell of count i.e., count[i] is another vector that stores all the elements whose set-bit-count is i
  2. Traverse the array and do the following for each element:
    1. Count the number set-bits of this element. Let it be ‘setbitcount’
    2. count[setbitcount].push_back(element)
  3. Traverse ‘count’ in reverse fashion(as we need to sort in non-increasing order) and modify the array.

Capture

C++






// C++ program to sort an array according to
// count of set bits using std::sort()
#include <bits/stdc++.h>
using namespace std;
 
// a utility function that returns total set bits
// count in an integer
int countBits(int a)
{
    int count = 0;
    while (a)
    {
        if (a & 1 )
            count+= 1;
        a = a>>1;
    }
    return count;
}
 
// Function to sort according to bit count
// This function assumes that there are 32
// bits in an integer.
void sortBySetBitCount(int arr[],int n)
{
    vector<vector<int> > count(32);
    int setbitcount = 0;
    for (int i=0; i<n; i++)
    {
        setbitcount = countBits(arr[i]);
        count[setbitcount].push_back(arr[i]);
    }
 
    int j = 0;  // Used as an index in final sorted array
 
    // Traverse through all bit counts (Note that we
    // sort array in decreasing order)
    for (int i=31; i>=0; i--)
    {
        vector<int> v1 = count[i];
        for (int i=0; i<v1.size(); i++)
            arr[j++] = v1[i];
    }
}
 
// Utility function to print an array
void printArr(int arr[], int n)
{
    for (int i=0; i<n; i++)
        cout << arr[i] << " ";
}
 
// Driver Code
int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6};
    int n = sizeof(arr)/sizeof(arr[0]);
    sortBySetBitCount(arr, n);
    printArr(arr, n);
    return 0;
}

Java




// Java program to sort an
// array according to count
// of set bits using std::sort()
import java.util.*;
class GFG{
 
// a utility function that
// returns total set bits
// count in an integer
static int countBits(int a)
{
  int count = 0;
  while (a > 0)
  {
    if ((a & 1) > 0 )
      count += 1;
    a = a >> 1;
  }
  return count;
}
 
// Function to sort according to
// bit count. This function assumes
// that there are 32 bits in an integer.
static void sortBySetBitCount(int arr[],
                              int n)
{
  Vector<Integer> []count =
         new Vector[32];
   
  for (int i = 0;
           i < count.length; i++)
    count[i] = new Vector<Integer>();
   
  int setbitcount = 0;
   
  for (int i = 0; i < n; i++)
  {
    setbitcount = countBits(arr[i]);
    count[setbitcount].add(arr[i]);
  }
 
  // Used as an index in
  // final sorted array
  int j = 0
 
  // Traverse through all bit
  // counts (Note that we sort
  // array in decreasing order)
  for (int i = 31; i >= 0; i--)
  {
    Vector<Integer> v1 = count[i];
     
    for (int p = 0; p < v1.size(); p++)
      arr[j++] = v1.get(p);
  }
}
 
// Utility function to print
// an array
static void printArr(int arr[],
                     int n)
{
  for (int i = 0; i < n; i++)
    System.out.print(arr[i] + " ");
}
 
// Driver Code
public static void main(String[] args)
{
  int arr[] = {1, 2, 3, 4, 5, 6};
  int n = arr.length;
  sortBySetBitCount(arr, n);
  printArr(arr, n);
}
}
 
// This code is contributed by 29AjayKumar

Python3




# Python3 program to sort an array according to
# count of set bits using std::sort()
 
# a utility function that returns total set bits
# count in an integer
def countBits(a):
    count = 0
    while (a):
        if (a & 1 ):
            count += 1
        a = a>>1
    return count
 
# Function to sort according to bit count
# This function assumes that there are 32
# bits in an integer.
def sortBySetBitCount(arr,n):
    count = [[] for i in range(32)]
    setbitcount = 0
    for i in range(n):
        setbitcount = countBits(arr[i])
        count[setbitcount].append(arr[i])
 
    j = 0 # Used as an index in final sorted array
 
    # Traverse through all bit counts (Note that we
    # sort array in decreasing order)
    for i in range(31, -1, -1):
        v1 = count[i]
        for i in range(len(v1)):
            arr[j] = v1[i]
            j += 1
 
# Utility function to pran array
def printArr(arr, n):
    print(*arr)
 
# Driver Code
arr = [1, 2, 3, 4, 5, 6]
n = len(arr)
sortBySetBitCount(arr, n)
printArr(arr, n)
 
# This code is contributed by mohit kumar 29

C#




// C# program to sort an
// array according to count
// of set bits using std::sort()
using System;
using System.Collections.Generic;
class GFG{
 
// a utility function that
// returns total set bits
// count in an integer
static int countBits(int a)
{
  int count = 0;
  while (a > 0)
  {
    if ((a & 1) > 0 )
      count += 1;
    a = a >> 1;
  }
  return count;
}
 
// Function to sort according to
// bit count. This function assumes
// that there are 32 bits in an integer.
static void sortBySetBitCount(int []arr,
                              int n)
{
  List<int> []count =
       new List<int>[32];
 
  for (int i = 0;
           i < count.Length; i++)
    count[i] = new List<int>();
 
  int setbitcount = 0;
 
  for (int i = 0; i < n; i++)
  {
    setbitcount = countBits(arr[i]);
    count[setbitcount].Add(arr[i]);
  }
 
  // Used as an index in
  // readonly sorted array
  int j = 0; 
 
  // Traverse through all bit
  // counts (Note that we sort
  // array in decreasing order)
  for (int i = 31; i >= 0; i--)
  {
    List<int> v1 = count[i];
 
    for (int p = 0; p < v1.Count; p++)
      arr[j++] = v1[p];
  }
}
 
// Utility function to print
// an array
static void printArr(int []arr,
                     int n)
{
  for (int i = 0; i < n; i++)
    Console.Write(arr[i] + " ");
}
 
// Driver Code
public static void Main(String[] args)
{
  int []arr = {1, 2, 3, 4, 5, 6};
  int n = arr.Length;
  sortBySetBitCount(arr, n);
  printArr(arr, n);
}
}
 
// This code is contributed by Amit Katiyar

Output:

3 5 6 1 2 4

Method 4: Using MultiMap
Steps :

  • Create a MultiMap whose key values will be the negative of the number of set-bits of the element.
  • Traverse the array and do following for each element:
    • Count the number set-bits of this element. Let it be ‘setBitCount’
    • count.insert({(-1) * setBitCount, element})
  • Traverse ‘count’ and print the second elements.

Below is the implementation of the above approach:

C++




// C++ program to implement
// simple approach to sort
// an array according to
// count of set bits.
#include<bits/stdc++.h>
using namespace std;
 
// Function to count setbits
int setBitCount(int num){
    int count = 0;
    while ( num )
    {
        if ( num & 1)
        count++;
        num >>= 1;
    }
    return count;
}
 
// Function to sort By SetBitCount
void sortBySetBitCount(int arr[], int n)
{   
    multimap< int, int > count;
   
    // Iterate over all values and
    // insert into multimap
    for( int i = 0 ; i < n ; ++i )
    {
        count.insert({(-1) *
            setBitCount(arr[i]), arr[i]});
    }
   
    for(auto i : count)
    cout << i.second << " " ;
    cout << "\n" ;
}
 
// Driver Code
int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6};
    int n = sizeof(arr)/sizeof(arr[0]);
    sortBySetBitCount(arr, n);
}
 
// This code is contributed by Ashok Karwa

Java




// Java program to implement
// simple approach to sort
// an array according to
// count of set bits.
import java.io.*;
import java.util.*;
class GFG
{
 
  // Function to count setbits
  static int setBitCount(int num)
  {
    int count = 0;
    while ( num != 0 )
    {
      if ( (num & 1) != 0)
        count++;
      num >>= 1;
    }
    return count;
  }
 
  // Function to sort By SetBitCount
  static void sortBySetBitCount(int[] arr, int n)
  {
    ArrayList<ArrayList<Integer>> count = new ArrayList<ArrayList<Integer>>();
 
    // Iterate over all values and
    // insert into multimap
    for( int i = 0 ; i < n ; ++i )
    {
      count.add(new ArrayList<Integer>(Arrays.asList((-1) * setBitCount(arr[i]), arr[i])));
    }
 
    Collections.sort(count, new Comparator<ArrayList<Integer>>() {   
      @Override
      public int compare(ArrayList<Integer> o1, ArrayList<Integer> o2) {
        return o1.get(0).compareTo(o2.get(0));
      }              
    });
 
    for(int i = 0; i < count.size(); i++)
    {
      System.out.print(count.get(i).get(1) + " ");
    }
 
  }
 
  // Driver code
  public static void main (String[] args)
  {
 
    int arr[] = {1, 2, 3, 4, 5, 6};
    int n = arr.length;
    sortBySetBitCount(arr, n);
  }
}
 
// This code is contributed by avanitrachhadiya2155

Python3




# Python3 program to implement
# simple approach to sort
# an array according to
# count of set bits.
 
# Function to count setbits
def setBitCount(num):
     
    count = 0
     
    while (num):
        if (num & 1):
            count += 1
             
        num = num >> 1
         
    return count
 
# Function to sort By SetBitCount
def sortBySetBitCount(arr, n):
     
    count = []
     
    # Iterate over all values and
    # insert into multimap
    for i in range(n):
        count.append([(-1) *
        setBitCount(arr[i]), arr[i]])
         
    count.sort(key = lambda x:x[0])
     
    for i in range(len(count)):
        print(count[i][1], end = " ")
 
# Driver Code
arr = [ 1, 2, 3, 4, 5, 6 ]
n = len(arr)
 
sortBySetBitCount(arr, n)
 
# This code is contributed by rag2127

C#




// C# program to implement
// simple approach to sort
// an array according to
// count of set bits.
using System;
using System.Collections.Generic;
class GFG {
     
    // Function to count setbits
    static int setBitCount(int num){
        int count = 0;
        while ( num != 0)
        {
            if ( (num & 1) != 0)
            count++;
            num >>= 1;
        }
        return count;
    }
     
    // Function to sort By SetBitCount
    static void sortBySetBitCount(int[] arr, int n)
    {   
        List<Tuple<int, int>> count = new List<Tuple<int, int>>(); 
        
        // Iterate over all values and
        // insert into multimap
        for( int i = 0 ; i < n ; ++i )
        {
            count.Add(new Tuple<int,int>((-1) * setBitCount(arr[i]), arr[i]));
        }
         
        count.Sort();
         
        foreach(Tuple<int, int> i in count)
        {
            Console.Write(i.Item2 + " ");
        }
        Console.WriteLine();
    }
 
  static void Main() {
    int[] arr = {1, 2, 3, 4, 5, 6};
    int n = arr.Length;
    sortBySetBitCount(arr, n);
  }
}

Output:

3 5 6 1 2 4

Time complexity: O(n log n)

Auxiliary Space: O(n)

This article is contributed by Nikhil Chakravartula and modified by Ashok Karwa. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :