1 手写快速排序

     function quickSort(arr) {
            if (arr.length < 2) return arr
            const baseVal = arr[0]
            const left = []
            const right = []
            for(let i = 1; i < arr.length; i++) {
                const item = arr[i]
                item > baseVal ? right.push(item) : left.push(item)
            }
            return [...quickSort(left), baseVal, ...quickSort(right)]
           
        }
        const res = quickSort([1,20,3,9])
        console.log(res) // [1,3,9,20]

2 冒泡排序

    const arr = [2, 100, 20, 25, 66, 55, 3]
    function fn(arr) {
        if (arr.length < 2) return arr
        for(let i = 0, len = arr.length; i < len; i++) {
            for(let j = i + 1, jlen = arr.length; j < jlen; j++) {
                if (arr[i] > arr[j]) {
                    [arr[i], arr[j]] = [arr[j], arr[i]]
                }
            }
        }
        return arr
    }
    const res = fn(arr)
    console.log(res)

3 两数之和

题目： 给定一个数组 nums 和一个目标值 target，在该数组中找出和为目标值的两个数
输入： nums: [8, 2, 6, 5, 4, 1, 3] ； target:7
输出： [2, 5]

 function twoNumAdd(arr, target) {
            if (!Array.isArray(arr)) return []
            let map = {}
            for (let i = 1; i < arr.length; i++) {
                 // 从map中查找是否有key 等于 target-nums[i]，如果有，则条件成立，返回结果
                if (map[target - arr[i]] !== undefined) {
                    return [target - arr[i], arr[i]]
                } else {
                    // 条件不成立，将该值存起来
                    map[arr[i]] = i
                }
            }
        }
        const rs = twoNumAdd([8, 2, 6, 5, 4, 1, 3], 7)
        console.log(rs)

4 第一个不重复的字符

题目： 输入一个字符串，找到第一个不重复字符的下标
输入： 'abcabcde'
输出： 6

function findOneStr(str) {
            const map = {}
            let res = -1
            for (let i = 0; i < str.length; i++) {
                const letter = str[i]
                map[letter] = map[letter] ? map[letter] + 1 : 1
            }
            
            for (let i = 0; i < str.length; i++) {
                if (map[str[i]] == 1) {
                    res = i
                    break
                }
            }
            return res;

5 列表转成树

  const data1 = [{
                id: 1,
                title: "child1",
                parentId: 0
            },
            {
                id: 2,
                title: "child2",
                parentId: 0
            },
            {
                id: 3,
                title: "child1_1",
                parentId: 1
            },
            {
                id: 4,
                title: "child1_2",
                parentId: 1
            },
            {
                id: 5,
                title: "child2_1",
                parentId: 2
            }
        ]
        function toTree(data) {
            const map = {}
            data.forEach(item => {
                map[item.id] = item
            })
            const container = []
            data.forEach(item => {
                const parentObj = map[item.parentId]
                if (parentObj) {
                    (parentObj.children || (parentObj.children = [])).push(item)
                } else {
                    container.push(item)
                }
            })
            return container
        }
        const res = toTree(data1)
        console.log(res)

6斐波那契数列

从第3项开始，当前项等于前两项之和： 1 1 2 3 5 8 13 21 ……，计算第n项的值

blog.csdn.net/weixin_3381…

      function fib(n) {
            if (n < 2) return 1
            const arr = [1,1]
            for(i = 2; i <= n; i++) {
                arr[i] = arr[i - 1] + arr[i - 2]
            }
            return arr[n]
        }
        const res = fib(10)
        console.log(res) // 89