数据结构与算法-LeetCode 格雷编码(No.89)

LeetCode 89. 格雷编码

格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。

给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。格雷编码序列必须以 0 开头。第一个数与最后一位数 也只差以为一位数 ‘首尾相连’ 所以又称为循环码或反射码

示例 1:

输入: 2
输出: [0,1,3,2]
解释:
00 - 0
01 - 1
11 - 3
10 - 2

对于给定的 n，其格雷编码序列并不唯一。
例如，[0,2,3,1] 也是一个有效的格雷编码序列。

00 - 0
10 - 2
11 - 3
01 - 1

示例 2:

输入: 0
输出: [0]
解释: 我们定义格雷编码序列必须以 0 开头。
     给定编码总位数为 n 的格雷编码序列，其长度为 2n。当 n = 0 时，长度为 20 = 1。
     因此，当 n = 0 时，其格雷编码序列为 [0]。

这题的难度主要是将给定的n转化为格雷编码

第一步 将n转变为格雷编码 1=>['0','1']

n = 1
0
1

n = 2
00
01
--
11
10

n = 3
000
001
011
010
---
110
111
101
100

分析上面的数字排列 我们可以注意到3点

• 以 -- 为间隔上面的编码与下面的编码是轴对称的（除了第一位以外）
• 后一个格雷编码 是以上一个为基础 做轴对称生成，并且前一半编码每项 '0'+'xxx' ,后一半编码每项 '1'+'xxx' ,
• 每组的编码的长度为2^n

先实现这部分逻辑

let make = (n) => {
 if (n === 1) {
   return ['0', '1']
 } else {
   let pre = make(n - 1)//获取上次的格雷编码
   let result = [] //存放结果
   let max = Math.pow(2, n) - 1//当前n个最后一位的索引
   for (let i = 0, len = pre.length; i < len; i++) {
     result[i] = `0${pre[i]}`
     result[max - i] = `1${pre[i]}`
   }
   return result
 }
}

完整解题

let make = (n) => {
 if (n === 1) {
   return ['0', '1']
 } else {
   let pre = make(n - 1)//获取上次的格雷编码
   let result = [] //存放结果
   let max = Math.pow(2, n) - 1//当前n个最后一位的索引
   for (let i = 0, len = pre.length; i < len; i++) {
     result[i] = `0${pre[i]}`
     result[max - i] = `1${pre[i]}`
   }
   return result
 }
}
let grayCode = (n) => {
 if (n === 0) return [0]

 let arr = make(n)
 return arr.map(item => {
   return parseInt(item, 2)  //parseInt(item,10)默认以十进制来换算
 })

};

将二进制转十进制 parseInt

parseInt(string, radix)  String -> Number
console.log(parseInt('11', 2));//返回一个数字 radix默认10 按照十进制解析 如果字符串的第一个字符不能转为数字 将返回NaN

提到这个 parseInt 就要提 toString

let num = 100;
NumberObject.toString(radix); Number -> String
console.log(num.toString(2));//返回一个字符串 radix默认10 按照十进制解析
"1100100"

最快的范例

他的思路其实也差不多 只是不采用递归的形式 比较直接 以 1=>['0', '1'] 为基础 生成目标格雷编码

var grayCode = function (n) {//n=2
  if (n === 0) return [0]

  const nums = ['0', '1']
  const arr_splice = Array.prototype.splice
  for (let t = 2; t <= n; t++) {
    let args = nums.slice().reverse()//['1','0']
    args.forEach((s, i) => args[i] = '1' + s)//['11','10']
    args.unshift(0)//['0',11','10']
    args.unshift(nums.length)//['2','0',11','10']
    console.log(args)
    nums.forEach((s, i) => nums[i] = '0' + s)// ['00', '01']
    arr_splice.apply(nums, args)// nums=> [ '00', '01', '11', '10' ]
  }
  return nums.map(binary => parseInt(binary, 2))
};

上面最关键步骤

const arr_splice = Array.prototype.splice
...
args.unshift(0)//['0',11','10']
args.unshift(nums.length)//['2','0',11','10']
...
arr_splice.apply(nums, args)// nums=> [ '00', '01', '11', '10' ]


['00', '01']+['11','10'] => [ '00', '01', '11', '10' ]
由于splice接受的是参数列表 arr.splice(2,0,'00','01') 不接受数组
所以巧妙的采用apply ，因为apply自身就是可以将集合的形式转变为参数列表的形式
这也是call 与apply的区别之一

如果喜欢LeetCode或者更多数据结构的内容， 可以戳这里 ,欢迎star

往期文章

• [数据结构与算法-LeetCode 种花问题(No.605)

]( https://juejin.im/post/5cd6c5...