Given an unsigned integer, reverse all bits of it and return the number with reversed bits.

Input : n = 1 Output : 2147483648 On a machine with size of unsigned bit as 32. Reverse of 0....001 is 100....0. Input : n = 2147483648 Output : 1

**Method1 – Simple**

Loop through all the bits of an integer. If a bit at ith position is set in the i/p no. then set the bit at (NO_OF_BITS – 1) – i in o/p. Where NO_OF_BITS is number of bits present in the given number.

`/* Function to reverse bits of num */` `unsigned ` `int` `reverseBits(unsigned ` `int` `num) ` `{ ` ` ` `unsigned ` `int` `NO_OF_BITS = ` `sizeof` `(num) * 8; ` ` ` `unsigned ` `int` `reverse_num = 0, i, temp; ` ` ` ` ` `for` `(i = 0; i < NO_OF_BITS; i++) ` ` ` `{ ` ` ` `temp = (num & (1 << i)); ` ` ` `if` `(temp) ` ` ` `reverse_num |= (1 << ((NO_OF_BITS - 1) - i)); ` ` ` `} ` ` ` ` ` `return` `reverse_num; ` `} ` ` ` `/* Driver function to test above function */` `int` `main() ` `{ ` ` ` `unsigned ` `int` `x = 2; ` ` ` `printf` `(` `"%u"` `, reverseBits(x)); ` ` ` `getchar` `(); ` `} ` |

*chevron_right*

*filter_none*

Above program can be optimized by removing the use of variable temp. See below the modified code.

`unsigned ` `int` `reverseBits(unsigned ` `int` `num) ` `{ ` ` ` `unsigned ` `int` `NO_OF_BITS = ` `sizeof` `(num) * 8; ` ` ` `unsigned ` `int` `reverse_num = 0; ` ` ` `int` `i; ` ` ` `for` `(i = 0; i < NO_OF_BITS; i++) ` ` ` `{ ` ` ` `if` `((num & (1 << i))) ` ` ` `reverse_num |= 1 << ((NO_OF_BITS - 1) - i); ` ` ` `} ` ` ` `return` `reverse_num; ` `} ` |

*chevron_right*

*filter_none*

Time Complexity: O(n)

Space Complexity: O(1)

**Method 2 – Standard**

The idea is to keep putting set bits of the num in reverse_num until num becomes zero. After num becomes zero, shift the remaining bits of reverse_num.

Let num is stored using 8 bits and num be 00000110. After the loop you will get reverse_num as 00000011. Now you need to left shift reverse_num 5 more times and you get the exact reverse 01100000.

`unsigned ` `int` `reverseBits(unsigned ` `int` `num) ` `{ ` ` ` `unsigned ` `int` `count = ` `sizeof` `(num) * 8 - 1; ` ` ` `unsigned ` `int` `reverse_num = num; ` ` ` ` ` `num >>= 1; ` ` ` `while` `(num) ` ` ` `{ ` ` ` `reverse_num <<= 1; ` ` ` `reverse_num |= num & 1; ` ` ` `num >>= 1; ` ` ` `count--; ` ` ` `} ` ` ` `reverse_num <<= count; ` ` ` `return` `reverse_num; ` `} ` ` ` `int` `main() ` `{ ` ` ` `unsigned ` `int` `x = 1; ` ` ` `printf` `(` `"%u"` `, reverseBits(x)); ` ` ` `getchar` `(); ` `} ` |

*chevron_right*

*filter_none*

Time Complexity: O(log n)

Space Complexity: O(1)

**Method 3 – Lookup Table:**

We can reverse the bits of a number in O(1) if we know the size of the number. We can implement it using look up table. Please refer Reverse bits using lookup table in O(1) time for details.

**Source : **

https://graphics.stanford.edu/~seander/bithacks.html

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.

## Recommended Posts:

- Write an Efficient Method to Check if a Number is Multiple of 3
- Write a program to reverse digits of a number
- Write a program to reverse an array or string
- Efficient program to print all prime factors of a given number
- Efficient program to print the number of factors of n numbers
- Check if bits of a number has count of consecutive set bits in increasing order
- Toggle bits of a number except first and last bits
- Reverse actual bits of the given number
- Efficient program to calculate e^x
- Efficient Program to Compute Sum of Series 1/1! + 1/2! + 1/3! + 1/4! + .. + 1/n!
- Print numbers having first and last bits as the only set bits
- Check if all bits can be made same by flipping two consecutive bits
- Reverse bits using lookup table in O(1) time
- An efficient way to check whether n-th Fibonacci number is multiple of 10
- Space efficient iterative method to Fibonacci number
- Check if a given number is Pronic | Efficient Approach
- Efficient way to multiply with 7
- Space and time efficient Binomial Coefficient
- Efficient method for 2's complement of a binary string
- Program to count number of set bits in an (big) array