javascript - 二叉搜索树 'remove' 函数的优化

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