格雷码

看到题目就想到了格雷码然后就疯狂搜索格雷码手动构造了一波格雷码看了题解 emmm 有点亏

理论基础

n 位格雷码序列 是一个由 2n 个整数组成的序列，其中：
- 每个整数都在范围 [0, 2n - 1] 内（含 0 和 2n - 1）
- 第一个整数是 0
- 一个整数在序列中出现 不超过一次
- 每对相邻整数的二进制表示 恰好一位不同 ，且
- 第一个 和 最后一个 整数的二进制表示 恰好一位不同
三位二进制数的格雷码序列为
$000, 001, 011, 010, 110, 111, 101, 100$
手动构造 $k$ 位格雷码

从全 $0$ 格雷码开始，按照下面策略：
1. 翻转最低位得到下一个格雷码;
2. 把最右边的 $1$ 的左边的位翻转得到下一个格雷码；
交替按照上述策略生成 $2^k-1$ 次，可得到 $k$ 位的格雷码序列
镜像构造格雷码

$k$ 位的格雷码可以从 $k - 1$ 位的格雷码以上下镜射后加上新位的方式快速得到
公式构造：从0开始构造 $k$ 位格雷码，第 $i$ 个格雷码为（下标从0开始）
$g_i=i \oplus\lfloor \frac {i}{2} \rfloor$
其实就是将十进制数 $0,2^k-1]$ 的二进制形式，转化为格雷码，转化过程为格雷码 = 自然二进制码 ^ 自然二进制码右移一位，右移一位的操作相当于整除2

相关题目

格雷编码【LC89】

n 位格雷码序列 是一个由 2n 个整数组成的序列，其中：

每个整数都在范围 [0, 2n - 1] 内（含 0 和 2n - 1）
第一个整数是 0
一个整数在序列中出现 不超过一次
每对相邻整数的二进制表示 恰好一位不同 ，且
第一个 和 最后一个 整数的二进制表示 恰好一位不同

给你一个整数 n ，返回任一有效的 n 位格雷码序列 。

手动构造

思路：交替手动构造

从全 $0$ 格雷码开始，按照下面策略：
1. 翻转最低位得到下一个格雷码;
2. 把最右边的 $1$ 的左边的位翻转得到下一个格雷码；
交替按照上述策略生成 $2^k-1$ 次，可得到 $k$ 位的格雷码序列

实现

class Solution {
    public List<Integer> grayCode(int n) {
        List<Integer> res = new ArrayList<>();
        int len = 1 << n;
        res.add(0);
        for (int i = 1; i < len; i++){
            // 交替构造
            if ((i & 1) == 1){
                // 反转最低位
                res.add(reverseIth(res.get(i - 1), 0));
            }else{
                int j = 0, pre = res.get(i - 1);
                while (((pre >> j) & 1) == 0){
                    j++;
                }
                // 反转最右边的1的左边的那位
                res.add(reverseIth(res.get(i - 1), j + 1));
            }
        }
        return res;
    }
    // 反转右边数第i位
    public int reverseIth(int num, int i){
        if (((num >> i) & 1) == 0){
            return num | (1 << i );// 设为1
        }else{
            return num & (~(1 << i));// 设为0
        }
    }
}

复杂度分析
- 时间复杂度： $O(2^n)$
- 空间复杂度： $O (1)$

镜像构造

思路：

$k$ 位的格雷码可以从 $k - 1$ 位的格雷码以上下镜射后加上新位的方式快速得到
实现

倒序遍历 $k - 1$ 位的格雷码，以此将第 $k$ 位赋值为1
```
class Solution {
    public List<Integer> grayCode(int n) {
        List<Integer> res = new ArrayList<>();
        res.add(0);
        for (int i = 0; i < n; i++){
            int m = res.size();
            for (int j = m - 1; j >= 0; j--){
                res.add(res.get(j) | (1 << i));
            }
        }
        return res;
    }
}
```
- 复杂度分析
  - 时间复杂度： $O(2^n)$
  - 空间复杂度： $O (1)$

公式构造

实现
```
class Solution {
    public List<Integer> grayCode(int n) {
        List<Integer> res = new ArrayList<>();
        for (int i = 0; i < 1 << n; i++){
            res.add(i ^ (i / 2));
        }
        return res;
    }
}
```
- 复杂度分析
  - 时间复杂度： $O(2^n)$
  - 空间复杂度： $O (1)$

循环码排列【LC1238】

给你两个整数 n 和 start。你的任务是返回任意 (0,1,2,,...,2^n-1) 的排列 p，并且满足：

p[0] = start
p[i] 和 p[i+1] 的二进制表示形式只有一位不同
p[0] 和 p[2^n -1] 的二进制表示形式也只有一位不同

先构造再添加

思路：

根据题意相邻二进制只有一位不相同，那么可以想到格雷码。可以将start看作某个格雷码的二进制形式，然后可以先按照题格雷编码【LC89】先从0开始构造出 $n$ 位的格雷码，在构造过程中记录与start相等的格雷码下标 $in d e x$ 。最后再从 $in d e x$ 遍历一次格雷码数组，将结果添加到结果集中。

实现

class Solution {
    public List<Integer> circularPermutation(int n, int start) {
        int len = 1 << n;
        int[] gray = new int[len];
        List<Integer> res = new ArrayList<>();
        int index = start;
        for (int i = 0; i < len; i++){
            gray[i] = i ^ (i >> 1);
            if (gray[i] == start) index = i;
        }
        for (int i = index;i < index + len; i++){
            res.add(gray[i % len ]);
        }
        return res;

    }


}

复杂度分析
- 时间复杂度： $O(2^n)$
- 空间复杂度： $O(2^n)$

异或start

思路：题格雷编码【LC89】从0开始构造出 $n$ 位的格雷码，那么我们可以在构造的每个结果上异或start，那么起始数值变为了start，又保证相邻数的二进制形式只有一位不同
```
class Solution {
    public List<Integer> circularPermutation(int n, int start) {
        int len = 1 << n;
        List<Integer> res = new ArrayList<>();
        for (int i = 0; i < len; i++){
            res.add(i ^ (i >> 1) ^ start);
        }
        return res;
    }


}
```
- 复杂度分析
  - 时间复杂度： $O(2^n)$
  - 空间复杂度： $O (1)$