js 二叉树算法

       //生成二叉树
        function binarySearchTree() {
            let Node = function(key) {
                this.key = key;
                this.left = null;
                this.right = null;
            }
            let root = null;
            //插入一个节点
            this.insert = function(key) {
                    let newNode = new Node(key);
                    root == null ? (root = newNode) : (insertNode(root, newNode))
                }
            //中序排列一个二叉树    对一个数组从小到大进行排序
            this.inOrderRraverse = function(callback) {
                    inOrderRraverseNode(root, callback);
                }
            //获取最大值
            this.max = function() {
                    return findMaxNode(root);
                }
            //获取最小值
            this.min = function() {
                    return findMinNode(root);
                }
            //判断指定的值是否存在
            this.search = function(key) {
                    return searchNode(root, key);
                }
            //删除指定的值
            this.remove = function(key) {
                root = removeNode(root, key);
            }
        }

        function removeNode(node, key) {
            if (node === null) { //node等于null
                return null;
            }
            if (key > node.key) { //node在右子树
                node.right = removeNode(node.right, key);
                return node;
            } else if (key < node.key) { //node在左子树
                node.left = removeNode(node.left, key);
                return node;
            } else { //node等于node.key
                //没有子节点
                if (node.left === null && node.right === null) {
                    node = null;
                    return node
                }
                //只有一个子节点
                if (node.left === null) {
                    node = node.right;
                    return node;
                } else if (node.right === null) {
                    node = node.left;
                    return node
                }
                //有两个子节点
                //从右子树中找到一个最小的节点作为node的key，右子树相当于删除一个子节点
                let aux = findMinNode(node.right);
                node.key = aux;
                node.right = removeNode(node.right, aux.key);
                return node;
            }

        }

        function searchNode(node, key) {
            if (node != null) {
                if (key > node.key) {
                    return searchNode(node.right);
                } else if (key < node.key) {
                    return searchNode(node.left);
                } else {
                    return true;
                }
            } else {
                return false;
            }
        }

        function findMaxNode(node) {
            if (node) {
                while (node && node.right) {
                    node = node.right;
                }
                return node.key;
            } else {
                return null;
            }
        }

        function findMinNode(node) {
            if (node) {
                while (node && node.left) {
                    node = node.left;
                }
                return node.key;
            } else {
                return null;
            }

        }

        function insertNode(node, newNode) {
            if (node.key > newNode.key) { //比父节点小，在左子树
                node.left == null ? (node.left = newNode) : (insertNode(node.left, newNode))
            } else {
                node.right == null ? (node.right = newNode) : (insertNode(node.right, newNode))
            }
        }

        function inOrderRraverseNode(node, callback) {
            if (node != null) {
                inOrderRraverseNode(node.left, callback)
                callback(node.key);
                inOrderRraverseNode(node.right, callback)
            }
        }

demo:

let tree = new binarySearchTree();
        let arr = [20, 40, 60, 70, 50, 10, 15, 4, 7];
        arr.map(item => {
            tree.insert(item);
        });
        console.log(tree);
        let callback = function(key) {
            console.log(key);
        }
        tree.inOrderRraverse(callback);
        console.log('max++++>' + tree.max());
        console.log('min++++>' + tree.min());
        console.log('search++++>' + tree.search(5));
        tree.remove(20);
        tree.inOrderRraverse(callback);

结果：

参考来自：https://cloud.tencent.com/developer/article/1482473