备战秋招60天算法挑战，Day20

题目链接： https://leetcode.cn/problems/reverse-bits/

视频题解： https://www.bilibili.com/video/BV1W2421Z7bi/

LeetCode 190.颠倒二进制位

题目描述

颠倒给定的 32 位无符号整数的二进制位。

举个例子：

输入：n = 00000010100101000001111010011100
输出：964176192 (00111001011110000010100101000000)
解释：输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596，
     因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。
1
2
3
4

视频题解

颠倒二进制位

思路来源

思路来源

知识回顾

1. 左移运算符 <<，可以将一个对象的二进制向左移n位，左边n位丢弃，右边n位补0。比如，a = 1101。

a << 2 = 0100
1

2. 右移运算符 >>，可以将一个对象的二进制向右移n位，右边n位丢弃，左边n位补0。比如，a = 1101。

a >> 2 = 0011
1

思路解析

方法一 按位颠倒

我们先将题目简化一下，对于一个8位的二进制10110111，如何进行颠倒成11101101呢？

先定义一个8位无符号的res = 0，我们将二进制的第i位，放到res的第7 - i位（位数从0开始）就可以完成整个过程的翻转。过程如下图：

针对上面的结论稍加修改就可以应用到32位无符号整数上面。

先定义一个存放结果的32位无符号变量 res = 0，循环遍历原串二进制的第i位，将其放到res的第31-i位，遍历完原串即得到最终翻转后的结果res。

C++代码

class Solution {
public:
    uint32_t reverseBits(uint32_t n) {
        uint32_t res = 0;
        for (int i = 0; i < 32; ++i) {
            //原串的第i位
            int bit = n & 1;
            //将原串的第i位放到res的第31-i位
            res |= (bit << (31 - i));
            n >>= 1;
        }
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

java代码

public class Solution {
    // you need treat n as an unsigned value
    public int reverseBits(int n) {
        int res = 0;
        for (int i = 0; i < 32; ++i) {
            // 原串的第i位
            int bit = n & 1;
            // 将原串的第i位放到res的第31-i位
            res |= (bit << (31 - i));
            n >>= 1;
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

python代码

class Solution:
    def reverseBits(self, n: int) -> int:
        res = 0
        for i in range(32):
            # 原串的第i位
            bit = n & 1
            # 将原串的第i位放到res的第31-i位
            res |= (bit << (31 - i))
            n >>= 1
        return res
1
2
3
4
5
6
7
8
9
10

方法二 分治

下面介绍另一种分治方法，对一些刚刷题的同学来说可能比较难理解。

• 把32位分成左右两部分16位，左右两部分交换。可以通过n = (n >> 16) | (n << 16)来做到。

• 把16位分成左右两部分8位，左右两部分交换。可以通过n = ((n & 0xff00ff00) >> 8) | ((n & 0x00ff00ff) << 8)来做到。16进制0x00ff00ff和32位二进制0000 0000 1111 1111 0000 0000 1111 1111是等价的，0xff00ff00和1111 1111 0000 0000 1111 1111 0000 0000是等价的。

• 把8位分成左右两部分4位，左右交换。可以通过n = ((n & 0xf0f0f0f0) >> 4) | ((n & 0x0f0f0f0f) << 4)来做到。16进制0xf0f0f0f0和二进制1111 0000 1111 0000 1111 0000 1111 0000是等价的，0x0f0f0f0f和0000 1111 0000 1111 0000 1111 0000 1111是等价的。

• 把4位分成左右两部分2位，左右交换。可以通过n = ((n & 0xcccccccc) >> 2) | ((n & 0x33333333) << 2)来做到。16进制0xcccccccc和二进制1100 1100 1100 1100 1100 1100 1100 1100等价，0x33333333和二进制0011 0011 0011 0011 0011 0011 0011 0011等价。

• 把2位分成左右两部分1位，左右交换。可以通过 n = ((n & 0xaaaaaaaa) >> 1) | ((n & 0x55555555) << 1)来实现。其中16进制0xaaaaaaaa和二进制1010 1010 1010 1010 1010 1010 1010 1010等价，0x55555555和0101 0101 0101 0101 0101 0101 0101 0101等价。

C++代码

class Solution {
public:
    uint32_t reverseBits(uint32_t n) {
        //左右16位交换
        n = (n >> 16) | (n << 16);
        //左右8位交换
        n = ((n & 0xff00ff00) >> 8) | ((n & 0x00ff00ff) << 8);
        //左右4位交换
        n = ((n & 0xf0f0f0f0) >> 4) | ((n & 0x0f0f0f0f) << 4);
        左右2位交换
        n = ((n & 0xcccccccc) >> 2) | ((n & 0x33333333) << 2);
        左右1位交换
        n = ((n & 0xaaaaaaaa) >> 1) | ((n & 0x55555555) << 1);
        return n;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

java代码

public class Solution {
    // you need treat n as an unsigned value
    public int reverseBits(int n) {
        // 左右16位交换
        n = ((n >> 16) & 0x0000ffff) | ((n << 16) & 0xffff0000);
        // 左右8位交换
        n = ((n >> 8) & 0x00ff00ff) | ((n << 8) & 0xff00ff00);
        // 左右4位交换
        n = ((n >> 4) & 0x0f0f0f0f) | ((n << 4) & 0xf0f0f0f0);
        // 左右2位交换
        n = ((n >> 2) & 0x33333333) | ((n << 2) & 0xcccccccc);
        // 左右1位交换
        n = ((n >> 1) & 0x55555555) | ((n << 1) & 0xaaaaaaaa);
        return n;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

python代码

class Solution:
    def reverseBits(self, n: int) -> int:
        # 左右16位交换
        n = (n >> 16) | (n << 16)
        # 左右8位交换
        n = ((n & 0xff00ff00) >> 8) | ((n & 0x00ff00ff) << 8)
        # 左右4位交换
        n = ((n & 0xf0f0f0f0) >> 4) | ((n & 0x0f0f0f0f) << 4)
        # 左右2位交换
        n = ((n & 0xcccccccc) >> 2) | ((n & 0x33333333) << 2)
        # 左右1位交换
        n = ((n & 0xaaaaaaaa) >> 1) | ((n & 0x55555555) << 1)
        return n
1
2
3
4
5
6
7
8
9
10
11
12
13

复杂度分析

时间复杂度： 两种方法都是 O(1)，最多处理32位，分治是log32位，都是常量时间。

空间复杂度： 两种方法都是 O(1)，只使用有限个整型变量。