# Sort an array according to count of set bits

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}```
Recommended Practice

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 ``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``// 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 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;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program to implement simple approach to sort an array``// according to count of set bits.``#include ` `// 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``// 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 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++)``        ``printf``(``"%d "``, 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;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// 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)`

## 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 ``# ( https://www.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 ``  ``// (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.`

## Javascript

 ``

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 ``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;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program to sort an array according to count of set bits``// using std::sort()``#include ` `// 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++)``        ``printf``(``"%d "``, 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;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## 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)``    ``{``        ``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() {``            ``@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)`

## 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)`

## C#

 `// C# program to sort an array according to count of set``// bits using Array.Sort() method``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;``using` `System.Linq;``class` `Program {` `  ``// Driver code ``  ``static` `void` `Main(``string``[] args) {``    ``int``[] arr = {``      ``1,``      ``2,``      ``3,``      ``4,``      ``5,``      ``6``    ``};``    ``int` `n = 6;``    ``SortBySetBitCount(arr, n);``    ``PrintArr(arr, n);``    ``Console.WriteLine();``  ``}` `  ``// Utility function to print an array``  ``private` `static` `void` `PrintArr(``int``[] arr, ``int` `n) {``    ``for` `(``int` `i = 0; i < n; i++)``      ``Console.Write(arr[i] + ``" "``);``  ``}` `  ``// Function to sort according to bit count using std::sort``  ``private` `static` `void` `SortBySetBitCount(``int``[] arr, ``int` `n) {``    ``Array.Sort(arr, ``new` `CountComparer());``  ``}` `  ``// custom comparator of std::sort``  ``private` `class` `CountComparer: IComparer < ``int` `> {``    ``public` `int` `Compare(``int` `x, ``int` `y) {``      ``int` `c1 = CountBits(x);``      ``int` `c2 = CountBits(y);``      ``// custom comparator of std::sort``      ``if` `(c1 <= c2)``        ``return` `1;``      ``else``        ``return` `-1;``    ``}` `    ``// a utility function that returns total set bits count in an integer``    ``private` `int` `CountBits(``int` `a) {``      ``int` `count = 0;``      ``while` `(a != 0) {``        ``if` `((a & 1) == 1)``          ``count += 1;``        ``a = a >> 1;``      ``}``      ``return` `count;``    ``}``  ``}``}` `// The code is contributed by Nidhi Goel.`

## Javascript

 ``

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.

## C++

 `// C++ program to sort an array according to``// count of set bits using std::sort()``#include ``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 > count(32);``    ``int` `setbitcount = 0;``    ``for` `(``int` `i=0; i=0; i--)``    ``{``        ``vector<``int``> v1 = count[i];``        ``for` `(``int` `i=0; i

## 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 []count = ``         ``new` `Vector[``32``];``  ` `  ``for` `(``int` `i = ``0``; ``           ``i < count.length; i++)``    ``count[i] = ``new` `Vector();``  ` `  ``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 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 print an 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`

## Javascript

 ``

Output
`3 5 6 1 2 4 `

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

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``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> count = ``new` `ArrayList>(); ` `    ``// Iterate over all values and ``    ``// insert into multimap``    ``for``( ``int` `i = ``0` `; i < n ; ++i ) ``    ``{``      ``count.add(``new` `ArrayList(Arrays.asList((-``1``) * setBitCount(arr[i]), arr[i])));``    ``}` `    ``Collections.sort(count, ``new` `Comparator>() {    ``      ``@Override``      ``public` `int` `compare(ArrayList o1, ArrayList 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> count = ``new` `List>();  ``       ` `        ``// 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);``  ``}``}`

## Javascript

 ``

Output
`3 5 6 1 2 4 `

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

Previous
Next