代码随想录算法训练营第二十二天|235. 二叉搜索树的最近公共祖先 ● 701.二叉搜索树中的插入操作 ● 450.删除二叉搜索树中的节点 （JS写法）

235 二叉搜索树的最近公共祖先

题目链接/文章讲解：https://programmercarl.com/0235.%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E7%9A%84%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88.html
视频讲解：https://www.bilibili.com/video/BV1Zt4y1F7ww

方法一：递归

考虑到二叉搜索树的特点，可以根据值得大小来判断p和q是在左子树还是右子树。
这个题的代码一开始我看了别人思路，也是这样写的，企图做递归，大体都是一样的，但是忘了return了，然后return root应该放在最外面

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */

/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
    //如果 p.val 和 q.val 都比 root.val 小，则p、q肯定在 root 的左子树
    if(p.val < root.val && q.val < root.val){
        return lowestCommonAncestor(root.left,p,q);
    }
    //如果 p.val 和 q.val 都比 root.val 大，递归右子树就行
    if(p.val > root.val && q.val > root.val){
        return lowestCommonAncestor(root.right,p,q);
    }
    //其他情况，root 即为所求
    return root;
    
};

方法二：迭代

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */

/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
    while(root){
        if(p.val < root.val && q.val < root.val){
            root = root.left;
        }else if(p.val > root.val && q.val > root.val){
            root = root.right;
        }else{
            break;
        }
    }
    return root;
};

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

题目链接/文章讲解：https://programmercarl.com/0701.%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E4%B8%AD%E7%9A%84%E6%8F%92%E5%85%A5%E6%93%8D%E4%BD%9C.html
视频讲解：https://www.bilibili.com/video/BV1Et4y1c78Y

方法一：自己写的

因为二叉搜索树中序遍历是有序的，我的第一想法就是先中序遍历得到有序数组，再插入数据，再根据有序数组构建二叉搜索树。写到要构建二叉搜索树那里不会了，问了chatgpt写的这种方法，但是有两个测试用例不通过，不知道为什么，但我觉得这个思路应该是正确的。从这道题也学一下怎么根据有序数组构建二叉搜索树。
更新：通过群友解答，知道是哪里出现了问题，下面这里，如果插入的数据是比所有数据都大的数，如果按照我这种写法，走不到最后，这里需要改成这样。


或者这样（第一种把index=i放在外面赋值，即使for循环结束，i也还是走到了最后，能定位到index的位置。）

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} val
 * @return {TreeNode}
 */
var insertIntoBST = function(root, val) {
    //中序遍历二叉搜索树
    let arr = [];
    const inorder = (root) => {
        if(root === null) return null;
        inorder(root.left);
        arr.push(root.val);
        inorder(root.right);
    }
    inorder(root);
    let index;
    for(let i = 1;i<arr.length;i++){
        if(arr[i-1] < val && arr[i] > val){
            index = i;
            break;
        }
    }
    arr.splice(index,0,val);
    // console.log(arr);
    //根据有序数组构建二叉搜索树
    const buildBST = (start, end) => {
        if (start > end) return null;        
        let mid = Math.floor((start + end) / 2);
        let newNode = new TreeNode(arr[mid]);        
        newNode.left = buildBST(start, mid - 1);
        newNode.right = buildBST(mid + 1, end);        
        return newNode;
    };    
    return buildBST(0, arr.length - 1);
};

方法二：递归

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} val
 * @return {TreeNode}
 */
var insertIntoBST = function(root, val) {
    if(root === null){
        return new TreeNode(val);
    }
    if(val < root.val){
        root.left = insertIntoBST(root.left,val);
    }else{
        root.right = insertIntoBST(root.right,val);
    }
    return root;
};

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

题目链接/文章讲解：https://programmercarl.com/0450.%E5%88%A0%E9%99%A4%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9.html
视频讲解：https://www.bilibili.com/video/BV1tP41177us

方法一：和上面插入节点一样的笨方法，就是效率很低但这个办法还蛮通用

注意index这里，一开始设置为-1，后面如果还是-1，就代表没有找到key，直接返回root即可

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} key
 * @return {TreeNode}
 */
var deleteNode = function(root, key) {
    let arr = [];
    const inorder = (root) => {
        if(root === null) return null;
        inorder(root.left);
        arr.push(root.val);
        inorder(root.right);
    }
    inorder(root);
    let index = -1;
    for(let i = 0;i<arr.length;i++){
        if(arr[i] === key){
            index = i;
            break;
        }
        
    }
    if(index === -1){
        return root;
    }
    arr.splice(index,1);
    //根据有序数组构建二叉搜索树
    const buildBST = (start,end) => {
        if(start > end){
            return null;
        }
        let mid = Math.floor((start + end) / 2);
        let newNode = new TreeNode(arr[mid]);
        newNode.left = buildBST(start,mid-1);
        newNode.right = buildBST(mid+1,end);
        return newNode;
    }
    return buildBST(0,arr.length - 1);
};

暂时不想看标准做法了。。。好复杂