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

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

题号：89

//回溯递归
var grayCode = function (n) {
    let binary = new Array(n).fill(0)
    let set = new Set()

    let b2d = (binarys) => {
        let sum = 0
        binarys.forEach((item,idx,arr) => {
            sum += item * Math.pow(2,arr.length - idx - 1)
        });
        return sum
    }
    let result = [0], count = Math.pow(2, n)
    set.add(0)
    let backtrack = (binarys) => {
        if (result.length == count) {
            return true
        }
        for (let i = 0; i < binarys.length; i++) {
            let num = binarys[i]
            //取反
            if (num == 0) {
                binarys[i] = 1
                let curSum = b2d(binarys)
                if (set.has(curSum)) {
                    //已经有了不符合题意
                    //回滚状态继续下一个字符
                    binarys[i] = 0
                    continue
                } else {
                    //没有可以作为一个值
                    result.push(curSum)
                    set.add(curSum)
                    if (backtrack(binarys)) {
                        return false
                    }
                    //回滚状态继续下一个字符
                    binarys[i] = 0
                }
            } else {
                binarys[i] = 0
                let curSum = b2d(binarys)
                if (set.has(curSum)) {
                    //已经有了不符合题意
                    //回滚状态继续下一个字符
                    binarys[i] = 1
                    continue
                } else {
                    //没有可以作为一个值
                    result.push(curSum)
                    set.add(curSum)
                    if (backtrack(binarys)) {
                        return true
                    }
                    //回滚状态继续下一个字符
                    binarys[i] = 1
                }
            }
        }
        return false
    }
    backtrack(binary)
    return result
};

题号：215

var findKthLargest = function (nums, k) {
    
    let count = k,endIdx = nums.length - 1
    while (count != 0) {
        buildheap(nums, endIdx)
        //首尾交换
        let tmp = nums[0]
        nums[0] = nums[endIdx]
        nums[endIdx] = tmp
        endIdx--
        count--
    }
    return nums[nums.length - k]
};
function buildheap(nums,endIdx) {
    
    //无序的数组长度
    let length = endIdx + 1
    for (let i = Math.floor(length/2) -1; i >=0; i--) {
        //从第一个非叶子节点开始
        //left child
        let left = i * 2 + 1
        //right child
        let right = i * 2 + 2
        //注意：堆通常是一个可以被看做一棵"完全二叉树"的数组对象
        //非叶子节点可能只有一个left
        if (right >= length) {
            //right下标数组越界了，right不存在，该非叶子节点
            //只有left
            if (nums[left]> nums[i]) {
                //交换
                let tmp = nums[i]
                nums[i] = nums[left]
                nums[left] = tmp
            }
        } else {
            //left right 都存在
            let max = left
            if (nums[max] < nums[right]) {
                max = right
            }
            if (nums[max] > nums[i]) {
                let tmp = nums[max]
                nums[max] = nums[i]
                nums[i] = tmp
            }
        }
    }
}

题号：7

//32位最小：-2147483648
//32位最大：2147483647

//数学运算
var reverse = function (x) {
    let result = 0
    let max = 2147483647
    let min = -2147483648
    do {
        let tmp = x % 10
        result = result * 10 + tmp
        x = parseInt(x / 10)
        if (result > max || result < min) {
            return 0
        }
    } while (x != 0);
    return result
};