前端面試(算法篇) - 約塞夫環

時間 2019-11-21

標籤前端面試算法欄目快樂工作简体版

原文原文鏈接

在上一篇《前端面試 - 算法篇（二分法）》的評論中，有朋友提出了一個「循環殺人遊戲」html

就在我爲之苦惱的時候，一位同事在我身旁通過，忽然說了一句：「咦，這不是約塞夫問題嗎？」前端

1、面試題面試

原題目不太明朗（一號到底殺不殺？）算法

因而把題目優化一下，更接近於本來的約塞夫問題數組

假設有100人，分別編號 1~100數據結構

從 1 號開始報數，報數到 3 號時，3 號就被淘汰，而後由下一人從 1 報數，以此類推函數

最後誰會活下來？性能

2、面向過程優化

最開始我按照本身的思路，模擬了整個過程this

雖然能解決問題，但一旦遇到較大的數據量，查詢的次數太多，性能過低

不過這種方法最容易理解

/**
 * 面向過程的約塞夫環解決辦法
 * @param {Array} peoples 參與遊戲的數組
 * @param {Number} kill 淘汰的報數數字
 * @return {Object} 倖存者
 */

function killer(peoples, kill) {
  
  let flag = 0 // 初始化報數

  while(peoples.length > 1) { // 只剩下一我的時，循環結束

    let len = peoples.length // 剩餘人數
    let out = 0 // 已淘汰的人數

    for (let i = 0; i < len; i++) {
      flag++ // 報數+1

      if (kill == flag) { // 當報數到指定數字，淘汰該玩家
        // 淘汰後剩餘人數(數組)會發生變化，因此被淘汰玩家下標應爲 i-out
        peoples.splice(i-out, 1)

        flag = 0 // 重置報數
        out++ // 淘汰人數+1
      }
    }
  }
  return peoples[0]
}

2、面向對象

在數據結構中，具備鏈式存儲結構的線性表被稱爲鏈表

其特色是每一個數據元素在存儲自己的信息以外，還要存儲其直接後繼的信息

數據元素之間不要求在存儲空間中連續

而當這些數據元素構成一個邏輯上的環，任意元素都有一個前驅和後繼，這就構成了一個循環鏈表

在這個遊戲中，能夠將玩家抽象成一個對象，而後由玩家組成了一個環

根據循環鏈表的特性，每一個玩家除了存儲自己的信息（編號），還須要存儲先後的編號

class Player { // 建立玩家
 constructor(n) { this.index = n; // 玩家編號
    this.before = {}; // 前一個玩家
    this.after = {}; // 後一個玩家
 } }

而後分析整個環，除了構造函數以外，還應當具有淘汰玩家、開始遊戲的功能

爲了保證環的完整，須要一個起點和一個終點，這兩個點在邏輯上是相鄰的

在整個遊戲過程當中，咱們只須要關心環的完整（起點、終點、玩家的前驅與後繼）就能夠了

/**
 * 面向對象的約塞夫環解決辦法
 * @param {Number} length 玩家總數
 * @param {Number} kill 淘汰的報數數字
 * @return
 */
class Cycle { // 建立循環鏈表
  constructor (length) {
    this.count = 0; // 玩家總數
    this.start = new Player(1) // 鏈表起點
    this.end = new Player(length) // 鏈表終點

    for(let i = 1; i <= length; i++) {
      // 建立玩家
      let player = new Player(i)
      this.count++

      if (this.count <= 1) {
        // 只有一個玩家的時候，起點和終點爲同一個玩家
        this.start = this.end = player
      } else {
        // 新建立的玩家必定位於鏈表終點以後
        this.end.after = player
        player.before = this.end
        // 而該玩家即爲新的鏈表終點
        this.start.before = player
        player.after = this.start
        this.end = player
      }
    }
  }

  delete (player) {
    if (this.count <= 1) { // 錯誤校驗
      this.start = this.end = null
      return
    } else {
      // 將先後的玩家關聯起來
      player.before.after = player.after
      player.after.before = player.before
      // 若是處於終點或起點，則修改相關信息
      if (player == this.start) {
        this.start = player.after
      } else if(player == this.end) {
        this.end = player.before
      }
    }
    // 淘汰該玩家
    player = null
    this.count--
  }

  play (kill) {
    let flag = 0 // 初始化報數
    let k = this.start // 從起點開始遊戲
    while (this.count > 1) { // 只剩一個玩家，循環結束
      flag++
      if (flag == kill) { // 報數到目標數字，淘汰玩家
        flag = 0
        this.delete(k)
      }
      // 不管淘汰與否，讓下一個玩家報數
      k = k.after
    }
    return `倖存者：${k.index}`
  }
}

new Cycle(100).play(3)

3、遞歸算法

在吃透了整個遊戲規則以後。。。

function Joseph(sum, value, n) {
    if ( n==1 ) {
        return ( sum + value - 1) % sum;
    } else {
        return ( Joseph( sum - 1, value, n - 1) + value ) % sum;
    }
}

console.log("剩下的人號數爲：" + (Joseph(100, 3, 100) + 1))