js实现搜索二叉树

1.树的优点：

 1.1.空间利用率很高

 1.2.树结构里面的元素是有规律的

 1.3.可以很快找到其中的最大值最小值

2.搜索二叉树实现BST（）：

const BST = function () {
    function Node (key) {
        this.key = key
        this.left = null
        this.right = null
    }
    // 属性
    this.root = null
    // 方法
    // 1.insert(key)插入一个元素
    BST.prototype.insert = function (key) {
        const newNode = new Node(key)
        if (this.root === null) {
            this.root = newNode
        } else {
            let cur = this.root
            while (cur) {
                if (cur.key > key) {
                if (cur.left) {
                        cur = cur.left
                    } else {
                        cur.left = newNode
                        return
                    }
                } else {
                    if (cur.right) {
                        cur = cur.right
                    } else {
                        cur.right = newNode
                        return
                    }
                }
            }
        }
    }
    // 2.search(key)查找键，找到返回true没找到返回false
    BST.prototype.search = function (key) {
        if (this.root === null) return false
        let cur = this.root
        while (cur.key !== key) {
            if (cur.key > key) {
                if (cur.left) {
                cur = cur.left
                }
            } else {
                if (cur.right) {
                    cur = cur.right
                    }
            }
            if (!cur) return false
        }
        return true
    }
    // 可以把中间判断的逻辑抽离出来，进行递归调用 insertNode

    BST.prototype.insertNode = function (node, newNode) {
        if (node.key > newNode.key) {
            if (node.left) {
                node = node.left
                this.insertNode(node, newNode)
            } else {
            node.left = newNode
            }
        } else {
            if (node.right) {
                node = node.right
                this.insertNode(node, newNode)
            } else {
                node.right = newNode
            }
        }
    }

 
    // 先递归函数
    BST.prototype.preOrderTraverseNode = function (node, handler) {
        console.log('node', node)
        if (node != null) {
            handler(node)
            this.preOrderTraverseNode(node.left, handler)
            this.preOrderTraverseNode(node.right, handler)
        } else {
        return
        }
    }
    // 中递归函数
    BST.prototype.inorderTraverseNode = function (node, handler) {
        if (node !== null) {
            this.inorderTraverseNode(node.left, handler)
            handler(node)
            this.inorderTraverseNode(node.right, handler)
        }
    }
    // 后递归函数

    BST.prototype.postOrderTraverseNode = function (node, handler) {
    if (node !== null) {
            this.postOrderTraverseNode(node.left, handler)
            this.postOrderTraverseNode(node.right, handler)
            handler(node)
        }
    }


    // 3.inOrderTraverse: 通过中序遍历方式遍历所有节点
    
    BST.prototype.inorderTraverse = function (handler) {
        this.inorderTraverseNode(this.root,handler)
    }
    // 4.preOrderTraverse: 通过先序遍历方式遍历所有节点(先对节点进行处理)
    BST.prototype.preOrderTraverse = function (handler) {
        console.log('this.root', this.root)
        this.preOrderTraverseNode(this.root, handler)
    }
    // 5.postOrderTraverse: 通过后续遍历方式遍历所有节点
    BST.prototype.postOrderTraverse = function (handler) {
        this.postOrderTraverseNode(this.root, handler)
    }
    // min：返回最小值的键

    BST.prototype.min = function () {
        if (!this.root) return false
        let cur = this.root
        while (cur.left) {
            cur = cur.left
            }
        return cur.key
    }

    // max：返回最大值的键
    BST.prototype.max = function () {
        if (!this.root) return false
        let cur = this.root
        while (cur.right) {
            cur = cur.right
        }
        return cur.key
    }