算法学习记录（六十五）

问：

1. 剑指 Offer 53 - II. 0～n-1中缺失的数字
2. 剑指 Offer 54. 二叉搜索树的第k大节点
3. 剑指 Offer 55 - I. 二叉树的深度
4. 剑指 Offer 51. 数组中的逆序对
5. 剑指 Offer 55 - II. 平衡二叉树 解：
6. 二分查找，看当前值跟当前下标的关系。等于的话表明缺的数还在后面，大于的话表明在前面

const missingNumber = function(arr) {
    let left = 0
    let right = arr.length - 1
    let flag = false
    while (left <= right) {
        const mid = Math.floor((left + right) >> 1)
        if (arr[mid] === mid) {
            left = mid + 1
        } else {
            flag = true
            right = mid - 1
        }
    }
    return flag ? arr[left] - 1 : arr[arr.length - 1] + 1
};

2. 中序逆序遍历二叉搜索树，形成从大到小的遍历，数到第k个结束

const kthLargest = function(root, k) {
    let res = null
    function getRes (node) {
        if (!node) return
        getRes(node.right)
        if (k) {
            res = node.val
            k--
        }
        getRes(node.left)

    }
    getRes(root)
    return res
};

3. 二叉树递归套路，找左右子树要信息，加工自己的信息返回

const maxDepth = function(root) {
    function getRes(node) {
        if (!node) return {
            deep: 0
        }
        const leftInfo = getRes(node.left)
        const rightInfo = getRes(node.right)
        return {
            deep: Math.max(leftInfo.deep, rightInfo.deep) + 1
        }
    }
    return getRes(root).deep
};

4. 就是找对每个数来说它比右边几个数大。归并排序中merge的时候形成降序数组，然后在左子数组和右子数组比较的时候，如果左子数组的当前值大于右子数组当前值，那么这个数就比此时右数组包括当前值往后所有值都大。

const reversePairs = function(arr) {
    if (!arr.length) return 0
    let total = 0
    function getRes(left, right) {
        if (left === right) {
            return arr.slice(left, right + 1)
        }
        const midIdx = Math.floor((left + right) / 2)
        const leftValue = getRes(left, midIdx)
        const rightValue = getRes(midIdx + 1, right)
        const res = []
        let leftIdx = 0
        let rightIdx = 0
        while (leftIdx < leftValue.length && rightIdx < rightValue.length) {
            if (leftValue[leftIdx] > rightValue[rightIdx]) {
                total += rightValue.length - rightIdx
                res.push(leftValue[leftIdx++])
            } else {
                res.push(rightValue[rightIdx++])
            }
        }
        while (leftIdx < leftValue.length) res.push(leftValue[leftIdx++])
        while (rightIdx < rightValue.length) res.push(rightValue[rightIdx++])
        return res
    }
    getRes(0, arr.length - 1)
    return total
};

5. 还是二叉树递归套路，左右子树同时是平衡树并且左右子树高度差不超过1。得到左右子树信息后加工出当前树的flag和deep信息返回即可

const isBalanced = function(root) {
    function getRes(node) {
        if (!node) return {
            flag: true,
            deep: 0
        }
        const leftInfo = getRes(node.left)
        const rightInfo = getRes(node.right)
        if (leftInfo.flag && rightInfo.flag) {
            const flag = Math.abs(leftInfo.deep - rightInfo.deep) <= 1
            return {
                flag,
                deep: Math.max(leftInfo.deep, rightInfo.deep) + 1
            }
        }
         return {
            flag: false
        }
    }
    return getRes(root).flag
};