字符串出现次数的TopK问题

function topKstrings( strings ,  k ) {
    const countMap = {};
    
    for (let i = 0; i < strings.length; i++) {
        const str = strings[i];
        const record = countMap[str] || (countMap[str] = [str, 0]);
        record[1] ++;
    }
    
    const countList = Object.values(countMap);
    countList.sort((i1, i2) => {
        const [s1, c1] = i1;
        const [s2, c2] = i2;
        
        return (c1 !== c2
            ? c1 < c2 ? 1 : -1
            : s1 < s2 ? -1 : 1
        );
    });
    
    return countList.slice(0, k);
}

/**
 * return topK string
 * @param strings string字符串一维数组 strings
 * @param k int整型 the k
 * @return string字符串二维数组
 */
function topKstrings( strings ,  k ) {
    let map = new Map();
    for(let i = 0; i < strings.length; i++){
        if(map.has(strings[i])){
            map.set(strings[i], (map.get(strings[i]) || 0) + 1)
        } else {
            map.set(strings[i], 1)
        }
    }
    let result = [...Array.from(map)].sort((a, b)=> {
        if(a[1] !== b[1]){
            return b[1]-a[1];
        } else {
            if(a[0] < b[0]){
                return -1;
            }
            return 0
        }
    });
    return result.slice(0, k);
}
module.exports = {
    topKstrings : topKstrings
};

function topKstrings( strings ,  k ) {
    // write code here
    strings.sort();
    const map = strings.reduce((pre, cur) => {
        if (pre.has(cur)) pre.set(cur, pre.get(cur) + 1);
        else pre.set(cur, 1);
        return pre;
    }, new Map());
    const res = [];
    map.forEach((val, key) => res.push([key, val]));
    res.sort((a, b) => b[1] - a[1]);
    return res.slice(0, k);
}

function topKstrings( strings ,  k ) {
    // write code here
    strings.sort()
    let res = []
    const map = new Map()
   for(let i=0; i<strings.length; i++){
        if(!map.has(strings[i])){
            map.set(strings[i], 1);
        }else{
            map.set(strings[i], map.get(strings[i])+1);
        }
    }
   map.forEach((val, key) => {
        res.push([key, val])
    })
    res.sort((sec, fir) => {
        return fir[1] - sec[1]
    })
    return res.slice(0,k)
}