sortIndex函數(shù)

我的實(shí)現(xiàn)

function sortIndex(array,value) {
    let len = array.length;
    let index = 0;



    while(index < len)  {
        if (value <= array[index]) {
            break
        }
        index++
    }

    return index
}

別人的實(shí)現(xiàn)

function baseSortedIndex(array, value) {
  let low = 0
  let high = array == null ? low : array.length

  if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
    while (low < high) {
      const mid = (low + high) >>> 1
      const computed = array[mid]
      if (computed !== null && !isSymbol(computed) && computed < value) {
        low = mid + 1
      } else {
        high = mid
      }
    }
    return high
  }
}

總結(jié)

• 主要是算法比我的好搞隐，使用的二分查找法部脚，時(shí)間復(fù)雜度是logn,比我的快讨越。照理說唱凯，這種算法我應(yīng)該很熟的。當(dāng)時(shí)寫代碼時(shí)應(yīng)該想得到的谎痢。
• 在算Math.floor((1+2) /2)時(shí)，用了(1+2) >>>1 來計(jì)算卷雕。

sortUniq函數(shù)

我的實(shí)現(xiàn)

function sortedUniq(array) {
    let len = array.length;
    let result = [];

    let preVal
    for(let val of array) {
        if (val != preVal) {
            result.push(val);
            preVal = val
        }
    }

    return result
}

別人的實(shí)現(xiàn)

function eq(value, other) {
  return value === other || (value !== value && other !== other)
}
function baseSortedUniq(array, iteratee) {
  let seen
  let index = -1
  let resIndex = 0

  const { length } = array
  const result = []

  while (++index < length) {
    const value = array[index], computed = iteratee ? iteratee(value) : value
    if (!index || !eq(computed, seen)) {
      seen = computed
      result[resIndex++] = value === 0 ? 0 : value
    }
  }
  return result
}

我的總結(jié)

• 算法是一致的节猿。因?yàn)樽⒁獾绞且呀?jīng)排序過的數(shù)組。所以沒有使用hash字典的算法來去重漫雕，雖然時(shí)間復(fù)雜度一致滨嘱，但是后者浪費(fèi)了空間
• 唯一的區(qū)別是別人實(shí)現(xiàn)的eq函數(shù)，這是一個(gè)嚴(yán)格判斷兩個(gè)變量是否相等的函數(shù)浸间，在這個(gè)eq函數(shù)中 1=== '1'是false）太雨，當(dāng)然代碼value !== value && other !== other是為了判斷eq(NaN, NaN)為true的。

union函數(shù)

我的實(shí)現(xiàn)

function union(...arrays) {
    let result = []
    let finalResult = []
    for (let val of arrays) {
        result = [...result, ...val]
    }


    //unique所有的數(shù)組
    let uniqueHashMap = {};
    for (let value of result) {
        debugger
        uniqueHashMap[value] = uniqueHashMap[value] ? (uniqueHashMap[value] + 1) : 1
    }

    console.log(uniqueHashMap)

    //循環(huán)uniqueHashMap 對象魁蒜，選取 uniqueHashMap[value]為1的數(shù)據(jù)
    console.log(Object.keys(uniqueHashMap))
    Object.keys(uniqueHashMap).forEach((val) => {
        finalResult.push(val)
    })

    return finalResult
}

別人的實(shí)現(xiàn)

function baseUniq(array, iteratee, comparator) {
  let index = -1
  let includes = arrayIncludes
  let isCommon = true

  const { length } = array
  const result = []
  let seen = result

  if (comparator) {
    isCommon = false
    includes = arrayIncludesWith
  }
  else if (length >= LARGE_ARRAY_SIZE) {
    const set = iteratee ? null : createSet(array)
    if (set) {
      return setToArray(set)
    }
    isCommon = false
    includes = cacheHas
    seen = new SetCache
  }
  else {
    seen = iteratee ? [] : result
  }
  outer:
  while (++index < length) {
    let value = array[index]
    const computed = iteratee ? iteratee(value) : value

    value = (comparator || value !== 0) ? value : 0
    if (isCommon && computed === computed) {
      let seenIndex = seen.length
      while (seenIndex--) {
        if (seen[seenIndex] === computed) {
          continue outer
        }
      }
      if (iteratee) {
        seen.push(computed)
      }
      result.push(value)
    }
    else if (!includes(seen, computed, comparator)) {
      if (seen !== result) {
        seen.push(computed)
      }
      result.push(value)
    }
  }
  return result
}

function union(...arrays) {
  return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true))
}

總結(jié)

• 算法都是一致的囊扳，先合并數(shù)組，然后數(shù)據(jù)去重兜看。只不過去重的方法不一樣锥咸。我采用的是hashmap的方式，當(dāng)時(shí)有一個(gè)問題 Object.keys(array)會(huì)將number類型轉(zhuǎn)化為string;lodash使用二層循環(huán)來去重细移，其他沒有什么差別