JavaScript数据结构之二叉搜索树

代码实现

/** 树节点 */
    class TreeNode {
        constructor(val) {
            this.value = val;
            this.left = null;
            this.right = null;
        }
    }

    /** 二叉搜索树 */
    class Tree {
        constructor(...args) {
            this.treeRoot = null;
            if (args && args.length) this.insertTreeNodeList(args);
        }
        /** 创建节点 */
        createTreeNode(val) {
            if (typeof val === 'number') {
                return new TreeNode(val);
            } else if (typeof val === 'string' && val !== '') {
                return new TreeNode(Number(val));
            }
            return null;
        }
        /** 
         * 插入节点
         * @param val 插入的值
         * @param node 要插入的节点
         */
        insertTreeNode(val, node = this.treeRoot) {
            // 先判断根节点是不是null，是null那么创捷节点赋值给根节点，不是null就插入
            if (!this.treeRoot) {
                this.treeRoot = this.createTreeNode(val);
            } else {
                if (val > node.value) {
                    if (!node.right) node.right = this.createTreeNode(val);
                    else this.insertTreeNode(val, node.right)
                } else {
                    if (!node.left) node.left = this.createTreeNode(val);
                    else this.insertTreeNode(val, node.left)
                }
            }
        }
        /**
         * 插入数组节点
         * @param vals 节点数组
         * 
         */
        insertTreeNodeList(vals = []) {
            vals.forEach(val => {
                this.insertTreeNode(val)
            })
        }
        /** 
         * 删除节点
         * @param val 节点值
        */
        delTreeNode(val, node = this.treeRoot) {
            // 要删除的节点
            const currTreeNode = this.getTreeNode(val);
            // 要删除节点的父节点
            const currTreeNodeParent = this.getTreeNodeParent(val);
            //  1.判断要删除的节点是叶子节点么，是叶子节点直接删除
            if (!currTreeNode.left && !currTreeNode.right) {
                if (currTreeNode === this.treeRoot) this.treeRoot = null;
                else {
                    if (currTreeNodeParent.left === currTreeNode) currTreeNodeParent.left = null;
                    else currTreeNodeParent.right = null;
                }
            }
            //  2.判断要删除的节点是否是两个子节点,该类只考虑后继补位
            else if (currTreeNode.left && currTreeNode.right) {
                // 获取后继
                const lastTreeNode = this.getNextor(currTreeNode);
                if (currTreeNode === this.treeRoot) {
                    this.treeRoot = lastTreeNode;
                } else if (currTreeNodeParent.left === currTreeNode) {
                    currTreeNodeParent.left = lastTreeNode;
                } else {
                    currTreeNodeParent.right = lastTreeNode;
                }
                lastTreeNode.left = currTreeNode.left
            }
            //  3.判断要删除的节点是否只有一个子节点
            else {
                // 要删除的节点只有左节点
                const delType = currTreeNode.left ? 'left' : 'right';
                if (currTreeNode === this.treeRoot) this.treeRoot = currTreeNode[delType];
                else {
                    if (currTreeNodeParent.left === currTreeNode) currTreeNodeParent.left = currTreeNode[delType];
                    else currTreeNodeParent.right = currTreeNode[delType];
                }
            }
        }
        /** 根据值获取节点 */
        getTreeNode(val, node = this.treeRoot) {
            if (!node) return null;
            else if (node.value === val) return node;
            else if (val > node.value) return this.getTreeNode(val, node.right);
            else return this.getTreeNode(val, node.left)
        }
        /** 根据值获取父节点 */
        getTreeNodeParent(val, node = this.treeRoot) {
            if (!node) return null;
            if (node.left && node.left.value === val) return node;
            if (node.right && node.right.value === val) return node;
            return this.getTreeNodeParent(val, node.left) || this.getTreeNodeParent(val, node.right)
        }
        /** 获取某个节点的后继,即获取该节点右子树里最小的一个节点 */
        getNextor(node = this.treeRoot) {
            if (!node.right) return null;
            const delNode = node;
            let parentNode = node;
            node = node.right;
            while (node.left) {
                parentNode = node;
                node = node.left;
            }
            parentNode.left = node.right;
            node.right = delNode.right;
            return node;
        }
        /** 获取某个节点的前驱,即获取该节点左子树里最大的一个节点 */
        getPrevor(node = this.treeRoot) {
            if (!node.left) return null;
            const delNode = node;
            let parentNode = node;
            node = node.left;
            while (node.right) {
                parentNode = node;
                node = node.right
            }
            parentNode.right = node.left;
            node.left = delNode.left;
            return node;
        }
        /** 先序遍历 */
        prevEach(node = this.treeRoot) {
            if (node) console.log(node.value);
            if (node && node.left) this.prevEach(node.left);
            if (node && node.right) this.prevEach(node.right)
        }
        /** 中序遍历 */
        midEach(node = this.treeRoot) {
            if (node && node.left) this.midEach(node.left)
            if (node) console.log(node.value)
            if (node && node.right) this.midEach(node.right)
        }
        /** 后续遍历 */
        nextEach(node = this.treeRoot) {
            if (node && node.left) this.nextEach(node.left)
            if (node && node.right) this.nextEach(node.right)
            if (node) console.log(node.value);
        }
    }

使用

    const tree = new Tree(7, 5, 9, 3, 8, 10);
    tree.insertTreeNode(6)
    console.log(tree.treeRoot)