优化二进制搜索树的“删除”功能

Question

我刚刚完成了我的第一个二叉搜索树remove功能，它非常需要优化。 我花了很多时间在这上，这是我能管理的最好的。 有没有更简单的方法可以做到这一点？ 有人对优化有任何建议吗？ 在我看来，这似乎必然是大量的代码。

对于初学者...

我的二叉搜索树...

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

我的“删除”功能...

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

如果您执行以下任一操作，将更有效率：

1. 结合prev()和find()通过返回前一个节点，并从发现的节点都find()
2. 给每个节点的父亲指针，只是顺藤摸瓜找到prev