数据结构与算法之数组: Leetcode 89. 格雷编码 (Typescript版)-Toy模板网

这篇具有很好参考价值的文章主要介绍了数据结构与算法之数组: Leetcode 89. 格雷编码 (Typescript版)。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

格雷编码

https://leetcode.cn/problems/gray-code/

描述

n 位格雷码序列是一个由 2n 个整数组成的序列，其中：
- 每个整数都在范围 [0, 2n - 1] 内（含 0 和 2n - 1）
- 第一个整数是 0
- 一个整数在序列中出现不超过一次
- 每对相邻整数的二进制表示恰好一位不同，且
- 第一个和最后一个整数的二进制表示恰好一位不同
- 给你一个整数 n ，返回任一有效的 n 位格雷码序列。

示例 1：

输入：n = 2
输出：[0,1,3,2]
解释：
[0,1,3,2] 的二进制表示是 [00,01,11,10] 。
- 00 和 01 有一位不同
- 01 和 11 有一位不同
- 11 和 10 有一位不同
- 10 和 00 有一位不同
[0,2,3,1] 也是一个有效的格雷码序列，其二进制表示是 [00,10,11,01] 。
- 00 和 10 有一位不同
- 10 和 11 有一位不同
- 11 和 01 有一位不同
- 01 和 00 有一位不同

示例 2：

输入：n = 1
输出：[0,1]

提示：

1 <= n <= 16

算法实现

1 ）方案 1

function grayCode(n: number): number[] {
  // 递归函数，用来算输入为n的格雷编码序列
  const recursionFn = (n: number) => {
    if (n === 1) {
      return ['0', '1']
    } else {
      const prev: string[] = recursionFn(n - 1)
      const result: string[] = []
      const max: number = Math.pow(2, n) - 1 // 最大值
      // 生成新的数组
      for (let i = 0, len = prev.length; i < len; i++) {
        result[i] = `0${prev[i]}` // 生成前i个，前一半
        result[max - i] = `1${prev[i]}` // 生成后一半，和上面是对称的（倒序）
      }
      return result
    }
  }
  return recursionFn(n).map(item => parseInt(item, 2)) // 这里二进制转十进制
}

这里是基于演草纸上画出得到一个规律
当n为1时
- 二进制输出：[0,1]，换成十进制输出是：[0,1]
- 0 - 0
- 1 - 1
- 这里还看不出什么
当n为2时
- 二进制输出：[0,1,11,10]，换成十进制就是 [0,1,3,2] 竖着看如下
- 00 - 0
- 01 - 1
- 11 - 3
- 10 - 2
- 从上面看出，最终是偶数个总数，中间劈开一半各自对称
  - 比如：00 对应 11；01对应10
当n为3时
- 输出：[0,1,11,10,110,111,101,100]，换成十进制是：[0,1,3,2,6,7,5,4]，竖着排列
- 000 - 0
- 001 - 1
- 011 - 3
- 010 - 2
- 110 - 6
- 111 - 7
- 101 - 5
- 100 - 4
- 从上述可以看到验证了上述规律
这里输入的n和n-1有关，直到和最后的1有关，而1就是 [‘0’, ‘1’]的字符串
这种方案属于归纳总结产生的，因为用到的是递归，容易爆栈，效率还不高

2 ）方案 2文章来源地址https://www.toymoban.com/news/detail-431460.html

function grayCode(n: number): number[] {
    // 初始化n为1位时的场景
    const result = [0, 1]
    // 对n位进行遍历
    for (let i = 1; i < n; i++) {
        const len = result.length
        // 倒序循环，内层循环一次完毕，会递增len的长度，也就是让result中的元素翻一倍
        for (let j = len - 1; j >= 0; j--) {
            // 进行左移操作，并加入当前的值
            result.push((1 << i) + result[j])
        }
    }
    return result
};