【前端算法系列】二叉搜索树

二叉搜索树特点：可为空树；或满足左子节点（最小） <= 根节点 <= 右子节点（最大），不存在相等值的节点；具有有序性

搜索效率之高：
1、线性查找：从左到右一个个查找，找10次。
2、比如搜索10，10大于9，又是二叉搜索树，所以一定在右边。找到13，10又比13小，所以找左边11；10又比11小，找左边
3、二叉查找树：如果这个数组是有序的，可以从中间开始查找，找到中间值8，10比8大，找右边；再进行二分，找中间值11，10小于11，最终找到10
4、哈希表，是无序的，会造成空间浪费

应用：

1. 查找数据域为某一特定值的结点
2. 插入新结点
3. 删除指定结点

基础操作

插入思路

1） 如果当前树没有任何一个结点，则直接把新结点当作根结点使用
2）如果当前树不为空，则从根结点开始

• 新结点 < 当前结点，则继续找当前结点的左子结点
• 新结点 > 当前结点，则继续找当前结点的右子结点
• 新结点 = 当前结点，则树中已经存在这样的结点，替换该结点的value值即可

function insertIntoBST(root, n) {
    // 若root为空，表示当前是可插入的空位，可直接插入
    if(!root) { 
        root = new TreeNode(n) // 创建值为n的结点，并插入到空位
        return root
    }
    
    if(root.val > n) { // 当前结点大于插入结点n，向左查找
        root.left = insertIntoBST(root.left, n)
    } else { // 当前结点小于插入结点n，向右查找
        root.right = insertIntoBST(root.right, n)
    }
    return root  // 返回插入后二叉搜索树的根结点
}

查询思路

从根结点开始：

• 查询结点 < 当前结点，则继续找当前结点的左子结点
• 查询结点 > 当前结点，则继续找当前结点的右子结点
• 查询结点 = 当前结点，则返回当前结点value

function search(root, n) {
    // 若root为空，查找失败，直接返回
    if(!root) return 
    // 找到目标结点，输出结点对象
    if(root.val === n) {
        console.log('目标结点是：', root)
    } else if(root.val > n) { // 当前结点大于查询结点n，向左查找
        search(root.left, n)
    } else { // 当前结点小于查询结点n，向右查找
        search(root.right, n)
    }
}

删除思路

1）找到被删除结点（树为null就return）
2）找到删除结点右子结点树中的最小结点minNode
3）删除右子树中的最小结点
4）让被删除结点的左子树成为最小结点minNode的左子树，让被删除结点的右子树称为最小结点minNode的右子树
5）让被删除结点的父结点指向最小结点minNode

// n是要删除的节点
function deleteNode(root, n) {
    // 如果没找到目标结点，则直接返回
    if(!root) return root

    if(root.val < n){ // 删除节点大于当前节点，继续寻找n节点的右子树（递归右子树找n，然后删除）
        root.right = deleteNode(root.right, n)
    }else if(root.val > n){ // 删除节点小于当前节点，继续寻找n节点的左子树（递归左子树找n，然后删除）
        root.left = deleteNode(root.left, n)
    }else{ // 找到目标节点
         // 若是叶子结点，则不需要想太多，直接删除
        if(!root.left && !root.right) {
            root = null
        } else if(root.left) {
            // 寻找左子树里值最大的结点（就是删除结点的右子树最小的结点）
            const maxLeft = findMax(root.left)
            // 用这个 maxLeft 覆盖掉需要删除的当前结点  
            root.val = maxLeft.val
            // 覆盖动作会消耗掉原有的 maxLeft 结点
            root.left = deleteNode(root.left, maxLeft.val)
        } else {
            // 寻找右子树里值最小的结点
            const minRight = findMin(root.right)
            // 用这个 minRight 覆盖掉需要删除的当前结点  
            root.val = minRight.val
            // 覆盖动作会消耗掉原有的 minRight 结点
            root.right = deleteNode(root.right, minRight.val)
        }
    }

    return root
}

// 寻找左子树最大值
function findMax(root) {
    while(root.right) {
        root = root.right
    }
    return root 
}

// 寻找右子树的最小值
function findMin(root) {
    while(root.left) {
        root = root.left
    }
    return root
}

98.验证二叉搜索树

二叉树特点：可以为空树；左 <= 根 <= 右

const isValidBST = function(root) {
  // 定义递归函数
  function dfs(root, minValue, maxValue) {
      // 若是空树也是二叉树
      if(!root)  return true

      // 若右孩子不大于根结点值，或者左孩子不小于根结点值，则不合法
      if(root.val <= minValue || root.val >= maxValue) return false

      // 左右子树必须都符合二叉搜索树大小关系
      return dfs(root.left, minValue,root.val) && dfs(root.right, root.val, maxValue)
  }
  // 初始化最小值和最大值为极小或极大
  return dfs(root, -Infinity, Infinity)
};

• 完整的

class Node {
    constructor(val) {
        this.val = val
        this.left = this.right = undefined
    }
}

class Tree {
    constructor(data) {
        let root = new Node(data.shift())
        // 遍历所有的数据，逐渐插入到当前这棵搜索树中去
        data.forEach(item => {
            this.insert(root, item)
        })
        return root
    }
    insert(node, data) {
        if (node.val > data) {
            if (node.left === undefined) {
                node.left = new Node(data)
            } else {
                this.insert(node.left, data)
            }
        } else {
            if (node.right === undefined) {
                node.right = new Node(data)
            } else {
                this.insert(node.right, data)
            }
        }
    }
    static walk(root) {
        if (!root.left && !root.right) {
            return true
        } else if ((root.left && root.val < root.left.val) || (root.right && root.val > root.right.val)) {
            return false
        } else {
            return Tree.walk(root.left) && Tree.walk(root.right)
        }
    }
}  
const root = new Tree([2, 1, 3])
console.log(root)
console.log(Tree.walk(root))

108.将有序数组转换为二叉搜索树

二叉搜索树的有序性：以中间元素为根结点，把数组递归创建成树

const sortedArrayToBST = function(nums) {
    // 处理边界条件
    if(!nums.length)  return null
    
    // root 结点是递归“提”起数组的结果
    const root = buildBST(0, nums.length-1)

    // 定义二叉树构建函数，入参是子序列的索引范围
    function buildBST(low, high) {
        // 当low > high时，意味着当前范围的数字已经被递归处理完全了
        if(low > high) return null
        // 二分一下，取出当前子序列的中间元素
        const mid = Math.floor(low + (high - low)/2)  
        // 将中间元素的值作为当前子树的根结点值
        const cur = new TreeNode(nums[mid]) 
        // 递归构建左子树，范围二分为[low,mid)
        cur.left = buildBST(low,mid-1)
        // 递归构建左子树，范围二分为为(mid,high]
        cur.right = buildBST(mid+1, high)
        return cur // 返回当前结点
    }
    
    return root // 返回根结点
}