C++实现LeetCode(190.颠倒二进制位)

[leetcode] 190. reverse bits 颠倒二进制位

reverse bits of a given 32 bits unsigned integer.

example 1:

input: 00000010100101000001111010011100
output: 00111001011110000010100101000000
explanation: the input binary string 00000010100101000001111010011100 represents the unsigned integer 43261596, so return 964176192 which its binary representation is 00111001011110000010100101000000.

example 2:

input: 11111111111111111111111111111101
output: 10111111111111111111111111111111
explanation: the input binary string 11111111111111111111111111111101 represents the unsigned integer 4294967293, so return 3221225471 which its binary representation is 10101111110010110010011101101001.

note:

• note that in some languages such as java, there is no unsigned integer type. in this case, both input and output will be given as signed integer type and should not affect your implementation, as the internal binary representation of the integer is the same whether it is signed or unsigned.
• in java, the compiler represents the signed integers using 2's complement notation. therefore, in example 2 above the input represents the signed integer -3 and the output represents the signed integer -1073741825.

follow up:

if this function is called many times, how would you optimize it?

credits:
special thanks to  for adding this problem and creating all test cases.

这道题又是在考察位操作 bit operation，leetcode 中有关位操作的题也有不少，比如 repeated dna sequences，single number,   single number ii ，和 grey code 等等。跟上面那些题比起来，这道题简直不能再简单了，我们只需要把要翻转的数从右向左一位位的取出来，如果取出来的是1，将结果 res 左移一位并且加上1；如果取出来的是0，将结果 res 左移一位，然后将n右移一位即可，参见代码如下：

解法一：

class solution {
public:
    uint32_t reversebits(uint32_t n) {
        uint32_t res = 0;
        for (int i = 0; i < 32; ++i) {
            if (n & 1 == 1) {
                res = (res << 1) + 1;
            } else {
                res = res << 1;
            }
            n = n >> 1;
        }
        return res;
    }
};

我们可以简化上面的代码，去掉 if...else... 结构，可以结果 res 左移一位，然后再判断n的最低位是否为1，是的话那么结果 res 加上1，然后将n右移一位即可，代码如下：

解法二：

class solution {
public:
    uint32_t reversebits(uint32_t n) {
        uint32_t res = 0;
        for (int i = 0; i < 32; ++i) {
            res <<= 1;
            if ((n & 1) == 1) ++res;
            n >>= 1;
        }
        return res;
    }
};

我们继续简化上面的解法，将 if 判断句直接揉进去，通过 ‘或' 上一个n的最低位即可，用n ‘与' 1提取最低位，然后将n右移一位即可，代码如下：

解法三：

class solution {
public:
    uint32_t reversebits(uint32_t n) {
        uint32_t res = 0;
        for (int i = 0; i < 32; ++i) {
            res = (res << 1) | (n & 1);
            n >>= 1;
        }
        return res;
    }
};

博主还能进一步简化，这里不更新n的值，而是直接将n右移i位，然后通过 ‘与' 1来提取出该位，加到左移一位后的结果 res 中即可，参加代码如下：

解法四：

class solution {
public:
    uint32_t reversebits(uint32_t n) {
        uint32_t res = 0;
        for (int i = 0; i < 32; ++i) {
            res = (res << 1) + (n >> i & 1);
        }
        return res;
    }
};

我们也可以换一种角度来做，首先将n右移i位，然后通过 ‘与' 1来提取出该位，然后将其左移 (32 - i) 位，然后 ‘或' 上结果 res，就是其颠倒后应该在的位置，参见代码如下： 

解法五：

class solution {
public:
    uint32_t reversebits(uint32_t n) {
        uint32_t res = 0;
        for (int i = 0; i < 32; ++i) {
            res |= ((n >> i) & 1) << (31 - i);
        }
        return res;
    }
};

github 同步地址：

类似题目：

number of 1 bits

reverse integer

参考资料：

https://leetcode.com/problems/reverse-bits/discuss/54938/a-short-simple-java-solution

https://leetcode.com/problems/reverse-bits/discuss/54772/the-concise-c++-solution(9ms)

https://leetcode.com/problems/reverse-bits/discuss/54741/o(1)-bit-operation-c++-solution-(8ms)

https://leetcode.com/problems/reverse-bits/discuss/54738/sharing-my-2ms-java-solution-with-explanation

https://leetcode.com/problems/reverse-bits/discuss/54873/java-two-methods-using-string-or-bit-operation-6ms-and-2ms-easy-understand

到此这篇关于c++实现leetcode(190.颠倒二进制位)的文章就介绍到这了,更多相关c++实现颠倒二进制位内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！