如果我正确理解你的问题，你想要这个（索引 | 二进制 | 位 rev. | bit rev. index）：

$$0\quad 000\quad 000\quad 0\\ 1\quad 001\quad 100\quad 4\\ 2\quad 010\quad 010\quad 2\\ 3\quad 011\quad 110\quad 6\\ 4\quad 100\quad 001\quad 1\\ 5\quad 101\quad 101\quad 5\\ 6\quad 110\quad 011\quad 3\\ 7\quad 111\quad 111\quad 7\\ $$

要找到下一个位反转地址，您只需将 N/2 从左到右添加到当前地址（不是我们通常的从右到左添加）。

考虑马特回答给出的图像中的情况，N = 8。对应于 1000。因此，N/2 = 4 = 100。

取第一个地址，X = 000 | 加 N/2 => 100，即 bit_reverse 地址 = 4 (100)

现在取一个新的，X = 100 | 加 N/2，这里要小心。

您需要从左到右添加，这与您通常在添加过程中所做的相反。

address  1 0 0 +
N/2      1 0 0
         ------
result   0 1 0  ----> 2
carry    1 0 0

现在你继续这个步骤，你会生成这样的地址，0-->4-->2-->6-->1-->5-->3-->7。

让我们再举一个例子。假设您到达了位反转地址 Y = 5。您需要找到下一个地址，只需将 N/2 添加到该地址即可。（我们知道答案是 3）。

address  1 0 1 +
N/2      1 0 0
         ------
result   0 1 1  ----> 3
carry    1 0 0

这就是生成位反转地址的方式。

假设所有先前计算的位反转的随机内存访问是可能的，假设 N 是 2 的幂，以下算法有效：

1. 从第一个索引 0 开始。
2. 将 N/2 添加到第一个索引以获得第二个索引。
3. 将 N/4 添加到前 2 个索引以获得接下来的 2 个索引。
4. 将 N/8 添加到前 4 个索引以获得接下来的 4 个索引。
5. 重复直到达到 N/N，这相当于在已计算的 N/2 索引上加 1。

N=8 的示例是：

1. 从 0 开始。
2. 下一个索引是 [0] + 8/2 = [4]。
3. 接下来的 2 个索引是 [0,4] + 8/4 → [2,6]
4. 接下来的 4 个索引（最后一个）是 [0,4,2,6] + 8/8 → [0,4,2,6,1,3,5,7]

这种方法的缺点是它需要内存查找，根据所使用的硬件，这可能会很昂贵。