Answer 1

这个理论是真理论啊，有没有可观察可实现的？

Answer 2

递归实现

/**
 * @param {Array} arr 数组
 * @param {Number} item 待查找项
 * @param {Number} min 第一个索引
 * @param {Number} max 最后一个索引
 */
function _binarySearch(arr, item, min = 0, max = arr.length - 1) {
  const half = Math.floor(min + (max - min) / 2)
  if (item < arr[half]) return _binarySearch(arr, item, min, half - 1)
  if (item > arr[half]) return _binarySearch(arr, item, half + 1, max)
  return half
}
/**
 * @param {Array} arr 数组
 * @param {Number} item 待查找项
 */
const binarySearch = (arr, item) => _binarySearch(arr, item) // 隐藏多余参数

循环实现：

/**
 * @param {Array} arr 数组
 * @param {Number} item 待查找项
 */
function binarySearch(arr, item) {
  let min = 0
  let max = arr.length - 1
  let half
  while (min <= max) {
    half = Math.floor(min + (max - min) / 2)
    if (item > arr[half]) {
      min = half + 1
    } else if (item < arr[half]) {
      max = half - 1
    } else {
      break
    }
  }
  return half
}

测试：

/**
 * test
 */
const res = binarySearch([1, 3, 66, 88, 233, 666], 666)
console.log('res: ', res) // 5

Answer 3

看一下我这个可以嘛

var a1 = ['A1', 'A2', 'B1', 'B2', 'C1', 'C2', 'D1', 'D2'];
var a2 =['A','B','C','D'];
var j=-1;
var arr=[]
for(let i=0;i<a1.length;i++){
    if(i%2 ===0){
	j++
	arr=arr.concat((a1.slice(i,i+2)).concat(a2[j]))
    }
}
console.log(arr)

——————————————————————
截图