日常刷题0x27之未出新手村

如果不小心网友来到了这里请网友自动飘走，浪费你们时间表示歉意。该系列博客的目的是：想作为自律工具和朋友一起每天刷几道题作为打卡督促的功能，没有什么可参考学习的东西，也不是刷博客量充大佬的目的

题号：264

//利用最小堆
var nthUglyNumber = function (n) {
    let map = new Map(), nums = [1], count = 1
    while (count <= n - 1) {
        let min = nums.shift()
        if (!map.has(2 * min)) {
            nums.push(2 * min)
            map.set(2 * min, 1)
        }
        if (!map.has(3 * min)) {
            nums.push(3 * min)
            map.set(3 * min, 1)
        }
        if (!map.has(5 * min)) {
            nums.push(5 * min)
            map.set(5 * min, 1)
        }
        heap(nums)
        count++
    }
    return nums[0]
};

function heap(nums) {
    let len = nums.length
    for (let i = Math.floor(len / 2) - 1; i >= 0; i--) {
        let left = 2 * i + 1, right = 2 * i + 2
        if (right >= len) {
            //only left
            if (nums[i] < nums[left]) {
                //swap
                let tmp = nums[i]
                nums[i] = nums[left]
                nums[left] = tmp
            }
        } else {
            //left right
            let min = left
            if (nums[min] > nums[right]) {
                min = right
            }
            if (nums[min] < nums[i]) {
                let tmp = nums[i]
                nums[i] = nums[min]
                nums[min] = tmp
            }
        }
    }
}

题号：179

var largestNumber = function (nums) {

    const strs = nums.map((x) => {
        return x.toString()
    })
    strs.sort((a, b) => {
        return (b + a) - (a + b)
    })
    let result = ""
    strs.forEach(ele => {
        result += ele
    });
    if (result.startsWith('0')) {
        return '0'
    }
    return result
};

题号：783

//在遍历的过程中就去比较获取最小差值
var minDiffInBST = function (root) {

    let min = Number.MAX_SAFE_INTEGER, preNode = null
    //中序遍历
    let traversal = (node) => {
        if (node == null) {
            return
        }
        traversal(node.left)
        //处理节点
        if (preNode) {
            //和前一个节点计算差值
            min = Math.min(node.val - preNode.val, min)
        }
        preNode = node
        traversal(node.right)
    }
    traversal(root)
    return min
};