代码

/**
 * @param {string[]} words
 * @param {number} k
 * @return {string[]}
 */
var topKFrequent = function(words, k) {
    words = words.sort();
    // words = words.sort((a, b) => a.localeCompare(b, {caseFirst: true}));
    let results = [];
    let counter = 0;
    let lastStr = null;
    let str;
    for(let i = 0; i < words.length; ++i){
        str = words[i];
        if(str !== lastStr){
            if(i !== 0){
                results.push({
                    str: lastStr,
                    counter
                });
            }
            counter = 1;
            lastStr = str;
        }
        else{
            counter++;
        }
    }
    results.push({
        str,
        counter
    });

    results = mergesort(results);
    // results.sort((a, b) => b.counter - a.counter); lc的引擎不是最新的
    return results.slice(0, k).reduce((list, el) => {
        list.push(el.str);
        return list;
    }, []);
    
    function bubbleSort(a) {
        var swapped;
        do {
            swapped = false;
            for (var i=0; i < a.length-1; i++) {
                if (a[i].counter < a[i+1].counter) {
                    var temp = a[i];
                    a[i] = a[i+1];
                    a[i+1] = temp;
                    swapped = true;
                }
            }
        } while (swapped);
    }
    
    function merge(leftArr, rightArr) {
      var sortedArr = [];
      while (leftArr.length && rightArr.length) {
        if (leftArr[0].counter >= rightArr[0].counter) {
          sortedArr.push(leftArr[0]);
          leftArr = leftArr.slice(1)
       } else {
          sortedArr.push(rightArr[0]);
          rightArr = rightArr.slice(1)
         }
       }
      while (leftArr.length)
        sortedArr.push(leftArr.shift());
      while (rightArr.length)
        sortedArr.push(rightArr.shift());
      return sortedArr;
    }
    function mergesort(arr) {
      if (arr.length < 2) {
        return arr; }
      else {
        var midpoint = parseInt(arr.length / 2);
        var leftArr   = arr.slice(0, midpoint);
        var rightArr  = arr.slice(midpoint, arr.length);
        return merge(mergesort(leftArr), mergesort(rightArr));
      }
    }
};

注意项

对word进行排序

对word进行排序的时候，使用sort即可，比localCompare快非常非常多
用localCompare的时候，速度超过 0.7% 改直接用sort 速度超过91%

根据counter的排序算法

最新的v8引擎，排序已经使用稳定算法，故会更快，但是测试了下，lc的js引擎不是最新的，使用的sort算法不是稳定算法，故自行实现了 效率较高的稳定算法 归并排序。

运行图