Sort an array according to count of set bits - GeeksforGeeks

02 May, 2022
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
Create an auxiliary array and store the set-bit counts of all integers in the aux arraySimultaneously sort both arrays according to the non-increasing order of auxiliary array. (Note that we need to use a stable sort algorithm)
Create an auxiliary array and store the set-bit counts of all integers in the aux array
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
Java
Python3
C#
Javascript
// C++ program to implement simple approach to sort an array// according to count of set bits.#include <bits/stdc++.h>using namespace std; // a utility function that returns total set bits count in an integerint 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// https://www.geeksforgeeks.org/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 arrayvoid 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 arrayvoid printArr(int arr[], int n){    for (int i = 0; i < n; i++)        cout << arr[i] << " ";} // Driver Codeint main(){    int arr[] = { 1, 2, 3, 4, 5, 6 };    int n = sizeof(arr) / sizeof(arr[0]);    sortBySetBitCount(arr, n);    printArr(arr, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// C program to implement simple approach to sort an array// according to count of set bits.#include <stdio.h> // a utility function that returns total set bits count in an integerint 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// https://www.geeksforgeeks.org/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 arrayvoid 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 arrayvoid printArr(int arr[], int n){    for (int i = 0; i < n; i++)        printf("%d ", arr[i]);} // Driver Codeint main(){    int arr[] = { 1, 2, 3, 4, 5, 6 };    int n = sizeof(arr) / sizeof(arr[0]);    sortBySetBitCount(arr, n);    printArr(arr, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// Java program to implement simple approach to sort an// array according to count of set bits.import java.io.*; class GFG {     // 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    // (https://www.geeksforgeeks.org/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 Aditya Kumar (adityakumar129)
# 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 integerdef 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 arraydef 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 arraydef printArr(arr, n):    for i in range(0,n,1):        print(arr[i],end = " ") # Driver Codeif __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# 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  // (https://www.geeksforgeeks.org/insertion-sort/ )  // Function to simultaneously  // sort both arrays using  // insertion sort  // (https://www.geeksforgeeks.org/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.
<script> // Javascript 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    function countBits(a)    {        let 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// (https://www.geeksforgeeks.org/insertion-sort/ )function insertionSort(arr,aux,n){    for (let i = 1; i < n; i++)    {        // use 2 keys because we        // need to sort both        // arrays simultaneously        let key1 = aux[i];        let key2 = arr[i];        let 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 arrayfunction sortBySetBitCount(arr,n){    // Create an array and    // store count of    // set bits in it.    let aux = new Array(n);    for (let 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 arrayfunction printArr(arr,n){    for (let i = 0; i < n; i++)        document.write(arr[i] + " ");} // Driver Codelet arr=[1, 2, 3, 4, 5, 6];let n = arr.length;sortBySetBitCount(arr, n);printArr(arr, n);          // This code is contributed by unknown2108     </script>
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
Java
Python3
Javascript
// 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 integerint countBits(int a){    int count = 0;    while (a) {        if (a & 1)            count += 1;        a = a >> 1;    }    return count;} // custom comparator of std::sortint 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::sortvoid sortBySetBitCount(int arr[], int n){    stable_sort(arr, arr + n, cmp);} // Utility function to print an arrayvoid printArr(int arr[], int n){    for (int i = 0; i < n; i++)        cout << arr[i] << " ";} // Driver Codeint main(){    int arr[] = { 1, 2, 3, 4, 5, 6 };    int n = sizeof(arr) / sizeof(arr[0]);    sortBySetBitCount(arr, n);    printArr(arr, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// C program to sort an array according to count of set bits// using std::sort()#include <stdio.h> // a utility function that returns total set bits count in an integerint countBits(int a){    int count = 0;    while (a) {        if (a & 1)            count += 1;        a = a >> 1;    }    return count;} // custom comparator of std::sortint 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::sortvoid sortBySetBitCount(int arr[], int n){    stable_sort(arr, arr + n, cmp);} // Utility function to print an arrayvoid printArr(int arr[], int n){    for (int i = 0; i < n; i++)        printf("%d ", arr[i]);} // Driver Codeint main(){    int arr[] = { 1, 2, 3, 4, 5, 6 };    int n = sizeof(arr) / sizeof(arr[0]);    sortBySetBitCount(arr, n);    printArr(arr, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// 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)    {        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)    {        for (int i = 0; i < n; i++)            System.out.print(arr[i] + " ");    }     private static Integer[] sortBySetBitCount(        Integer[] arr, int n)    {        Arrays.sort(arr, new Comparator<Integer>() {            @Override            public int compare(Integer arg0, Integer arg1)            {                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 Aditya Kumar (adityakumar129)
# Using custom comparator lambda functionarr = [1, 2, 3, 4, 5, 6]  # form a tuple with val, indexn = 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 indexsorted_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)
<script>// Javascript program to sort an array according to// count of set bits using std::sort() function  printArr(arr,n){    // TODO Auto-generated method stub        for (let i = 0; i < n; i++)            document.write(arr[i] + " ");            } function sortBySetBitCount(arr,n){    arr.sort(function(a,b){        c1 = Number(a.toString(2).split("").sort().join("")).toString().length;        c2 = Number(b.toString(2).split("").sort().join("")).toString().length;                 return c2-c1;    })} let arr = [1, 2, 3, 4, 5, 6 ];let  n = 6;sortBySetBitCount(arr, n);printArr(arr, n);document.write(); // This code is contributed by ab2127</script>
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):
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 iTraverse the array and do the following for each element:Count the number set-bits of this element. Let it be ‘setbitcount’count[setbitcount].push_back(element)Traverse ‘count’ in reverse fashion(as we need to sort in non-increasing order) and modify the array.
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
Traverse the array and do the following for each element:Count the number set-bits of this element. Let it be ‘setbitcount’count[setbitcount].push_back(element)
Count the number set-bits of this element. Let it be ‘setbitcount’count[setbitcount].push_back(element)
Count the number set-bits of this element. Let it be ‘setbitcount’
count[setbitcount].push_back(element)
Traverse ‘count’ in reverse fashion(as we need to sort in non-increasing order) and modify the array.
C++
Java
Python3
C#
Javascript
// 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 integerint 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 arrayvoid printArr(int arr[], int n){    for (int i=0; i<n; i++)        cout << arr[i] << " ";} // Driver Codeint 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 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 integerstatic 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 arraystatic void printArr(int arr[],                     int n){  for (int i = 0; i < n; i++)    System.out.print(arr[i] + " ");} // Driver Codepublic 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 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 integerdef 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 print an arraydef printArr(arr, n):    print(*arr) # Driver Codearr = [1, 2, 3, 4, 5, 6]n = len(arr)sortBySetBitCount(arr, n)printArr(arr, n) # This code is contributed by mohit kumar 29
// 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 integerstatic 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 arraystatic void printArr(int []arr,                     int n){  for (int i = 0; i < n; i++)    Console.Write(arr[i] + " ");} // Driver Codepublic 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
<script>// Javascript 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 integerfunction countBits(a){    let 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.function sortBySetBitCount(arr,n){let count = new Array(32);      for (let i = 0;           i < count.length; i++)    count[i] = [];      let setbitcount = 0;      for (let i = 0; i < n; i++)  {    setbitcount = countBits(arr[i]);    count[setbitcount].push(arr[i]);   }    // Used as an index in  // final sorted array  let j = 0;    // Traverse through all bit  // counts (Note that we sort  // array in decreasing order)  for (let i = 31; i >= 0; i--)  {    let v1 = count[i];          for (let p = 0; p < v1.length; p++)      arr[j++] = v1[p];  }} // Utility function to print// an arrayfunction printArr(arr,n){    for (let i = 0; i < n; i++)        document.write(arr[i] + " ");} // Driver Codelet arr = [1, 2, 3, 4, 5, 6];let n = arr.length;sortBySetBitCount(arr, n);printArr(arr, n); // This code is contributed by patel2127</script>
Output:
3 5 6 1 2 4
Method 4: Using MultiMapSteps:
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})
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++
Java
Python3
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 setbitsint setBitCount(int num){    int count = 0;    while ( num )    {        if ( num & 1)        count++;        num >>= 1;    }    return count;} // Function to sort By SetBitCountvoid 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 Codeint 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 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 program to implement# simple approach to sort# an array according to# count of set bits. # Function to count setbitsdef setBitCount(num):         count = 0         while (num):        if (num & 1):            count += 1                     num = num >> 1             return count # Function to sort By SetBitCountdef 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 Codearr = [ 1, 2, 3, 4, 5, 6 ]n = len(arr) sortBySetBitCount(arr, n) # This code is contributed by rag2127
// 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 write.geeksforgeeks.org or mail your article to review-team@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.
vt_m
prasad gujar
Sach_Code
SURENDRA_GANGWAR
Rohan_Kansara
mohit kumar 29
ashokkarwa087
29AjayKumar
amit143katiyar
muditmalpani1997
rag2127
subhammahato348
avanitrachhadiya2155
divyeshrabadiya07
unknown2108
patel2127
ab2127
surinderdawra388
adityakumar129
Deutsche Bank
Arrays
Sorting
Arrays
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Introduction to Arrays
Multidimensional Arrays in Java
Linear Search
Linked List vs Array