刷题随记 - 11.二叉搜索树相关

参考：公众号：labuladong

leetcode 230. 二叉搜索树中第K小的元素

直接中序遍历，即可升序遍历二叉搜索树的所有节点。

var kthSmallest = function(root, k) {
    let index = 0
    let result = 0
    function traverse(root, k){
        if(root == null){
            return null
        }
        traverse(root.left, k)
        index++ // 这里index需要从0先加，刚刚好能完全遍历所有
        if(k === index){
            result = root.val // 设置全局变量取结果值
            return
        }
        traverse(root.right, k)
    }
    traverse(root, k)
    return result
};

leetcode 538. 把二叉搜索树转换为累加树

这里打破了思维固化，一直觉得要先左子树后右子树。

这里反过来，仍然是中序遍历框架，但是先 右后中再左 遍历。可以降序遍历BST。

var convertBST = function(root) {
    let sum = 0
    function traverse(root){
        if(root == null){
            return
        }

        traverse(root.right)
        sum += root.val
        root.val = sum
        traverse(root.left)
    }
    traverse(root)
    return root
};

leetcode 98. 验证二叉搜索树

问题：

解决：关键就是要解决如何将根约束传递下去

思想：

• 左子树最大值是父节点的值
• 右子树最小值是父节点的值

方法：设置辅助函数，辅助函数中传入多个参数

var isValidBST = function(root) {
    function traverse(root, min, max){
        if(root == null){
            return true
        }

        if(max != null && root.val >= max.val){
            return false
        }

        if(min != null && root.val <= min.val){
            return false
        }
        // 限定左子树最大值是 root.val 限定右子树最小值是 root.val
        return traverse(root.left, min, root) && traverse(root.right, root, max) // 注意这里的且运算，要将左右子树的结果且运算后，才是最终结果！！
    }
    return traverse(root, root.val)
};

leetcode 700.二叉搜索树中的搜索

这道题引出二叉搜索树的框架：

void BST(TreeNode root, int target) {
    if (root.val == target)
        // 找到目标，做点什么
    if (root.val < target) 
        BST(root.right, target);
    if (root.val > target)
        BST(root.left, target);
}

var searchBST = function(root, val) {
    if(root == null){
        return null
    }
    if(root.val === val){
        return root
    }
    if(root.val < val){
        return searchBST(root.right, val)
    }else if(root.val > val){
        return searchBST(root.left, val)
    }
};

leetcode 701.二叉搜索树中的插入操作

分析：

• 比根节点值大，插入到右边
• 比根节点值小，插入到左边
• 这颗二叉搜索树最初的结构不会变，新增的节点只能是在叶子上面
• 为空，则直接生成叶子节点即可。

错误版本：

var insertIntoBST = function(root, val) {
    // 在JS中，就算你传入了null（空的指针），他也没办法像C++那样，赋值后直接改变指针所指向的内存
    // 所以，这段代码，没办法添加 改变 root.left或者 root.right
    function insert(root, val){
        if(root == null){
            root = new TreeNode(val)
            return
        }
        if(root.val > val){
            insert(root.left, val)
        }else if (root.val < val){
            insert(root.right, val)
        }
    }
    insert(root, val)
    return root
}

分析：

• 在JS中，没有指针概念
• 函数传入的虽然是引用类型，但是，只能给引用类型增加或删除属性方法等
• 没办法像使用指针那样，没办法直接更改指针本身的值。
• 所以，return的值要有人接才行。

    // 递归的神奇之处，多个 return 语句，但是仍然要顺序读下来。
    // 第一个是终止条件，只在终止的时候发生。
    // 接下来的解读就是，根节点的值比val大，进入左子树，否则进入右子树，执行完毕。返回 root。不要陷入递归
    if(root == null){
        return new TreeNode(val)
    }
    if(root.val > val){
    	// 递归返回的值要有人接
        root.left = insertIntoBST(root.left, val)
    }else if (root.val < val){
        root.right = insertIntoBST(root.right, val)
    }
    return root

leetcode 450.删除二叉搜索树中的节点

分析：

• 情况1，删除的节点是叶子节点，没有左右孩子，则直接删除
• 情况2，只有一个孩子：删除的节点只有左孩子，则让左孩子顶上来；若只有右孩子，则让右孩子顶上来。
• 情况3，有两个孩子：删除该节点后，需要让左孩子中最大节点顶上来，或让右孩子中最小节点顶上来。

var deleteNode = function(root, key) {
    if(root == null){
        return null
    }
    if(root.val === key){
        // 下面两条 if 判断的情况，其实就包含了这条 if 判断的情况，因此，这条 if 多余
        // if(root.left == null && root.right == null){
        //     return null
        // }
        // 情况1，左为空，右顶上
        if(root.left == null){
            return root.right
        }
        // 情况2，右为空，左顶上，左右都为空，那无所谓，谁顶都一样，所以，第一条 if 冗余
        if(root.right == null){
            return root.left
        }
        // 情况3，都不为空，找左边最大，或者右边最小顶上，这里找右边最小
        const minValueNode = (function(root){
            // 这里会不会改变指针所指向的对象呢？不会，所以JS函数调用，传入的参数，哪怕是对象，也不会改变其指针指向的内存中的值
            while(root.left){
                root = root.left
            }
            return root
        })(root.right)
        root.val = minValueNode.val
        // 删除那个被拉上来的最小值
        root.right = deleteNode(root.right, minValueNode.val)
    }else if(root.val > key){
        root.left = deleteNode(root.left, key)
    }else if(root.val < key){
        root.right = deleteNode(root.right, key)
    }
    return root
    
};

总结：

1. 如果当前节点会对下面的子节点有整体影响，可以通过辅助函数增长参数列表，借助参数传递信息。
2. 在二叉树递归框架之上，扩展出一套 BST 代码框架

void BST(TreeNode root, int target) {
    if (root.val == target)
        // 找到目标，做点什么
    if (root.val < target) 
        BST(root.right, target);
    if (root.val > target)
        BST(root.left, target);
}

3. 根据代码框架掌握了 BST 的增删查改操作。