Question

There is a method in Java that reverses bits in an Integer reverseBytes(). I wanted to try another implementation and this is what I have:

public static int reverse(int num) {

        int num_rev = 0;
        for (int i = 0; i < Integer.SIZE; i++) {
            System.out.print((num >> i) & 1);

            if (((num >> i) & 1)!=0) {

                num_rev = num_rev | (int)Math.pow(2, Integer.SIZE-i);
            }

        }
        return num_rev;
}

The result num_rev is not correct. Does anyone have any idea how to “reconstruct” the value? Maybe there is a better way to perform it?

Thanks for any suggestions.

Answer 1

The normal way would to reverse bits would be via bit manipulation, and certainly not via floating point math routines!

e.g (nb: untested).

int reverse(int x) {
    int y = 0;
    for (int i = 0; i < 32; ++i) {
        y <<= 1;       // make space
        y |= (x & 1);  // copy LSB of X into Y
        x >>>= 1;      // shift X right
    }
    return y;
}

Because x is right shifted and y left shifted the result is that the original LSB of x eventually becomes the MSB of y.

A nice (and reasonably well known) method is this:

unsigned int reverse(unsigned int x)
{
    x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
    x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
    x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
    x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
    return ((x >> 16) | (x << 16));
}

This is actually C code, but as Java doesn’t have unsigned types to port to Java all you should need to do is remove the unsigned qualifiers and use >>> instead of >> to ensure that you don’t get any “sign extension”.

It works by first swapping every other bit, then every other pair of bits, then every other nybble, then every other byte, and then finally the top and bottom 16-bit words. This actually works 🙂