數據結構與算法-LeetCode 格雷編碼(No.89)

時間 2019-11-10

原文原文鏈接

LeetCode 89. 格雷編碼

格雷編碼是一個二進制數字系統，在該系統中，兩個連續的數值僅有一個位數的差別。
給定一個表明編碼總位數的非負整數 n，打印其格雷編碼序列。格雷編碼序列必須以 0 開頭。第一個數與最後一位數也只差覺得一位數 ‘首尾相連’ 因此又稱爲循環碼或反射碼git

示例 1:github

輸入: 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:web

輸入: 0
輸出: [0]
解釋: 咱們定義格雷編碼序列必須以 0 開頭。
     給定編碼總位數爲 n 的格雷編碼序列，其長度爲 2n。當 n = 0 時，長度爲 20 = 1。
     所以，當 n = 0 時，其格雷編碼序列爲 [0]。

這題的難度主要是將給定的n轉化爲格雷編碼算法

第一步將n轉變爲格雷編碼 1=>['0','1']

分析上面的數字排列咱們能夠注意到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
 }
}

完整解題app

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)默認以十進制來換算
 })

};

將二進制轉十進制 parseIntpost

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'] 爲基礎生成目標格雷編碼spa

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