JS算法——心血来潮篇！

LRU缓存算法

class LRU {
        //设置数据、长度
        constructor(capacity) {
            this.data = new Map();
            this.capacity = capacity;
        }
        //获取时将目标数据提前
        get(key) {
            if (this.data.has(key)) {
                let value = this.data.get(key);
                this.data.delete(key);
                this.data.set(key, value)
                return value;
            } else {
                return null;
            }
        }
        set(key, value) {
            if (this.data.has(key)) {
                this.data.delete(fistKey);
            } else if (this.data.size === this.capacity) {
               //如果超出了容量，则需要删除最早的数据
                let fistKey = this.data.keys().next().value
                this.data.delete(fistKey);
            }
            this.data.set(key, value)
        }
    }

const lru = new LRU(5);

数组扁平化

function flatten(arr) {
    let res = [];
    for (let i = 0; i < arr.length; i++) {
        if (Array.isArray(arr[i])) {
            // res.push(flatten(arr[i])) 只可能会减少嵌套层级
            res = res.concat(flatten(arr[i]));
        } else {
            res.push(arr[i]);
        }
    }
    return res;
}

const flatten = arr => arr.reduce((acc,cur)=>{acc.concat(Array.isArray(cur) ? cur : flatten(cur))},[])

统计字符串中各个字符出现的次数

function countCharacters(str) {
    const charCount = {};
    for (let char of str) {
        charCount[char] = (charCount[char] || 0) + 1;
    }
    return charCount;
}

function fun(str) {
    return str.split('').reduce((acc, cur) => {
        if (acc[cur]) {
            acc[cur] += 1;
        } else {
            acc[cur] = 1;
        }
        return acc;
    }, {});
}

按指定位置对数组排序

// 需要排序的数组
const globalArray = [
    {"id": "1", "value": "A"},
    {"id": "2", "value": "B"},
    {"id": "3", "value": "C"},
    {"id": "4", "value": "D"},
    {"id": "5", "value": "E"},
    {"id": "6", "value": "F"}
];
// 排序参数
const sortParams = [
    {"id": "3", "sort": "6"}, //将id为3的项挪到第6位
    {"id": "1", "sort": "5"},
    {"id": "2", "sort": "3"}
];

function reorder(sortParams) {
    // 足够大的数组
    const sortedArray = new Array(globalArray.length).fill(null);
    // 将 sortParams 中指定的项放到 sortedArray 中
    sortParams.forEach(param => {
        const index = parseInt(param.sort, 10) - 1;
        const item = globalArray.find(element => element.id === param.id);
        sortedArray[index] = item;
    });
   // 获取在 globalArray 中存在但不在 sortParams 中的项
    const remainingItems = globalArray.filter(element => {
        return !sortParams.map(param => param.id).includes(element.id);
    });

    // 填充剩余的项到排序后的数组中空的位置
    let remainingIndex = 0;
    for (let i = 0; i < sortedArray.length; i++) {
        if (sortedArray[i] === null && remainingItems[remainingIndex]) {
            sortedArray[i] = remainingItems[remainingIndex];
            remainingIndex++;
        }
    }
    // 更新全局数组
    globalArray.length = 0;
    globalArray.push(...sortedArray);
}

斐波那契数列

// [0,1,1,2,3,5,8...]
const fibonacci = n =>
  Array(n).fill(0).reduce((acc, val, i) => 
    acc.concat(i > 1 ? acc[i - 1] + acc[i - 2] : i), []);