Question

我刚刚完成了我的第一个二叉搜索树remove功能，它主要需要优化。我花了很多时间在这上面，这是我能管理的最好的。有更简单的方法吗？有没有人有任何优化建议？对我而言，它似乎一定是大规模的代码。

首先......

我的二进制搜索树...

function BST() {
    this.root = null;
}

我的＆＃39;删除＆＃39;功能...

BST.prototype.remove = function(data) {
    if(this.root.data === data){
        var curr = this.root.left;
        while(true){
            if(curr.right.left === null && curr.right.right === null){
                this.root.data = curr.right.data;
                curr.right = null;
                break;
            }
            curr = curr.right;
        }
    }

    var curr = this.root;
    var found_data = this.find(data);
    if(found_data.left !== null && found_data.right !== null){
        var runner = found_data.right;
        var runner_prev = found_data;
        while(true){
            if(runner.left === null && runner.right === null){
                found_data.data = runner.data;
                if(runner_prev.left === runner){
                    runner_prev.left = null;
                }else{
                    runner_prev.right = null;
                }
                break;
            }
            runner_prev = runner;
            runner = runner.left;
        }
    }else if(found_data.left === null || found_data.right === null){
        var prev = this.prev(found_data.data);
        if(prev.right === found_data){
            if(found_data.left){
                prev.right = found_data.left;
            }else{
                prev.right = found_data.right;
            }
        }else{
            if(found_data.left){
                prev.left = found_data.left;
            }else{
                prev.left = found_data.right;
            }
        }
    }else{
        var prev = this.prev(found_data.data);
        if(prev.left === found_data){
            prev.left = null;
        }else{
            prev.right = null;
        }
    }

};

您会注意到我在remove()函数中使用了支持函数，例如prev()和find()它们是我的首要BST()函数的一部分，可以在任何地方使用内部是使用this.进行前缀。

我在remove()（prev()和find()）

中使用的支持功能

BST.prototype.find = function(data) {
    if(this.root === null){
        return 'wrong';
    }

    var curr = this.root;
    while(true){
        if(data > curr.data){
            curr = curr.right;
        }else if(data < curr.data){
            curr = curr.left;
        }else{
            if(curr.data enter code here=== data){
                return curr;
            }else{
                return 'not here player'
            }
        }
    }
}

BST.prototype.prev = function(data){
    if(this.root === null){
        return false;
    }
    var prev = this.root;
    var curr = this.root;
    while(true){
        if(curr.left === null && curr.right === null){
            return prev;
        }
        if(data < curr.data){
            prev = curr;
            curr = curr.left;
        }else if(data > curr.data){
            prev = curr;
            curr = curr.right;
        }else{
            return prev;
        }
    }
}

这个算法绝对有效，但是你可以想象，这不是你想要回答白板面试问题的怪物类型。

Answer 1

如果你这样做会更有效率：

通过从prev()

find()

为每个节点指定一个父指针，然后单击它以查找prev

二进制搜索树的优化＆＃39;删除＆＃39;功能

1 个答案: