日常刷题0x3之德玛蹲草丛

此阶段给自己定的目标是：做过的这些题每天坚持继续刷二遍，每道题做过之后开始尝试多解法尝试解题。上一阶段是感知都有什么题目，此阶段主要系统化常规题解套路知识，牢记牢记此阶段目的。

题号：636

//最开始想到的双指针超时
//因为有个点还需要剪枝掉
var judgeSquareSum = function (c) {
    let left = 0, right = c
    while (left <= right) {
        let sum = Math.pow(left, 2) + Math.pow(right, 2)
        if (sum == c) {
            return true
        } else if (sum > c) {
            right--
        } else {
            left++
        }
    }
    return false
};

var judgeSquareSum = function (c) {
    // 取floor不取floor铁定要超了c
    //这里对right的可能情况要剪枝掉已经不可能会出结果的枚举情况
    let left = 0, right = Math.floor(Math.sqrt(c))
    while (left <= right) {
        let sum = Math.pow(left, 2) + Math.pow(right, 2)
        if (sum == c) {
            return true
        } else if (sum > c) {
            right--
        } else {
            left++
        }
    }
    return false
};

题号：100

//递归搜索遍历比较
var isSameTree = function (p, q) {

    let helper = (node1, node2) => {

        if (node1 == null && node2 == null) {
            return true
        }
        if (node1 == null || node2 == null) {
            return false
        }
        return node1.val == node2.val && helper(node1.left, node2.left) && helper(node1.right, node2.right)
    }
    return helper(p, q)
};

题号：450

var deleteNode = function (root, key) {

    //后序遍历搜索key
    let helper = (node) => {
        if (node == null) {
            return null
        }
        helper(node.left)
        helper(node.right)
        //处理当前节点
        if (node.left && node.left.val == key) {
            //要删除的节点是当前节点的左节点
            if (node.left.right == null) {
                //要删除的节点没有右子节点
                //把左最低按直接接到父节点的left
                node.left = node.left.left
            } else {
                //tmp保存将要删除的节点
                let tmp = node.left
                node.left = node.left.right
                //从将要删除的节点的右子节点的左子节点一路找左找到一个最左的位置
                //把将要删除的节点的左节点放到上面找到的位置的left处
                let lastLeftNode = node.left
                while (lastLeftNode.left) {
                    lastLeftNode = lastLeftNode.left
                }
                lastLeftNode.left = tmp.left
                //把将要删除的节点的左右自节点置空
                tmp.left = null
                tmp.right = null
            }
        }
        if (node.right && node.right.val == key) {
            //要删除的节点是当前节点的右节点
            if (node.right.right == null) {
                node.right = node.right.left
            } else {
                let tmp = node.right
                node.right = node.right.right

                let lastLeftNode = node.right
                while (lastLeftNode.left) {
                    lastLeftNode = lastLeftNode.left
                }
                lastLeftNode.left = tmp.left

                tmp.left = null
                tmp.right = null
            }
        }
    }
    //设置一个头节点方便统一处理逻辑要不然要单独判断删除的节点是根节点还是非根节点
    let head = new TreeNode(-1)
    head.left = root
    helper(head)
    return head.left
};

题号：701

var insertIntoBST = function (root, val) {
    if (root == null) {
        let newNode = new TreeNode(val)
        return newNode
    }
    let curNode = root
    while (curNode) {
        if (curNode.val > val) {
            //要插入的节点在当前节点的右边
            if (curNode.left == null) {
                let newNode = new TreeNode(val)
                curNode.left = newNode
                break
            } else {
                //继续寻找
                curNode = curNode.left
            }
        } else {
            //要插入的节点在当前节点的左边
            if (curNode.right == null) {
                let newNode = new TreeNode(val)
                curNode.right = newNode
                break
            } else {
                //继续寻找
                curNode = curNode.right
            }
        }
    }
    return root
};

题号：700

//递归
var searchBST = function (root, val) {

    let result = null
    let helper = (node) => {
        if (node == null) {
            return null
        }
        helper(node.left)
        if (node.val == val) {
            result = node
        }
        helper(node.right)
    }
    helper(root)
    return result
};

//迭代
var searchBST = function (root, val) {

    let curNode = root
    while (curNode) {

        if (curNode.val > val) {
            curNode = curNode.left
        } else if (curNode.val == val) {
            return curNode
        } else {
            curNode = curNode.right
        }
    }
    return null
};