javascript二叉搜索树

树结构

     function BinarySearchTree() {
            function Node(key) {
                this.key = key;
                this.left = null;
                this.right = null;
            }
            // 属性
            this.root = null;

            BinarySearchTree.prototype.insert = function (key) {
                // 根据key创建节点
                var newNode = new Node(key);
                // 判断根节点是否存在
                if (this.root == null) {
                    this.root = newNode;
                } else {
                    this.insertNode(this.root, newNode)
                }

            }

            BinarySearchTree.prototype.insertNode = function (node, newNode) {
                if (newNode.key < node.key) {
                    // 向左查找
                    if (node.left == null) {
                        node.left = newNode;
                    } else {
                        this.insertNode(node.left, newNode);
                    }
                } else {
                    // 向右查找
                    if (node.right == null) {
                        node.right = newNode;
                    } else {
                        this.insertNode(node.right, newNode);
                    }
                }
            }

            // 先序遍历
            BinarySearchTree.prototype.preOrderTraversal = function (handler) {
                this.preOrderTraversalNode(this.root, handler);
            }

            BinarySearchTree.prototype.preOrderTraversalNode = function (node, handler) {
                if (node != null) {
                    // 处理经过的节点
                    handler(node.key);
                    // 处理经过节点的子节点
                    this.preOrderTraversalNode(node.left, handler);
                    this.preOrderTraversalNode(node.right, handler);
                }
            }
            // 中序遍历
            BinarySearchTree.prototype.midOrderTraversal = function (handler) {
                this.midOrderTraversalNode(this.root, handler);
            }

            BinarySearchTree.prototype.midOrderTraversalNode = function (node, handler) {
                if (node != null) {

                    // 处理经过节点的子节点
                    this.midOrderTraversalNode(node.left, handler);
                    // 处理经过的节点
                    handler(node.key);
                    this.midOrderTraversalNode(node.right, handler);
                }
            }

            // 后序遍历
            BinarySearchTree.prototype.postOrderTraversal = function (handler) {
                this.postOrderTraversalNode(this.root, handler);
            }

            BinarySearchTree.prototype.postOrderTraversalNode = function (node, handler) {
                if (node != null) {

                    // 处理经过节点的子节点
                    this.postOrderTraversalNode(node.left, handler);

                    this.postOrderTraversalNode(node.right, handler);
                    // 处理经过的节点
                    handler(node.key);
                }
            }

            // 最小值
            BinarySearchTree.prototype.min = function () {
                var node = this.root;
                var key = null;
                while (node != null) {
                    key = node.key;
                    node = node.left;

                }
                return key;
            }
            // 最大值
            BinarySearchTree.prototype.max = function () {
                var node = this.root;
                var key = null;
                while (node != null) {
                    key = node.key;
                    node = node.right;

                }
                return key;
            }

            BinarySearchTree.prototype.search = function (key) {
                var node = this.root;
                while (node != null) {
                    if (key < node.key) {
                        node = node.left;
                    } else if (key > node.key) {
                        node = node.right;
                    } else {
                        return true;
                    }
                }
                return false;
            }
            BinarySearchTree.prototype.remove = function (key) {
                // 寻找要删除的节点
                var current = this.root;
                var parent = null;
                var isLeftChild = true;
                while (current.key != key) {
                    parent = current;
                    if (key < current.key) {
                        isLeftChild = true;
                        current = current.left;
                    } else {
                        isLeftChild = true;
                        current = current.right;
                    }
                    // 节点没找到
                    if (current == null) {
                        return false;
                    }
                }
                // 根据对应情况删除节点
                // 删除的节点是叶子节点
                if (current.left == null && current.right == null) {
                    if (current == this.root) {
                        this.root = null;
                    } else if (isLeftChild) {
                        parent.left = null;
                    } else {
                        parent.right = null;
                    }
                }
                else if (current.right == null) {
                    if(current == this.root) {
                        this.root = current.left;
                    }
                    // 删除的节点只有一个子节点
                    else if (isLeftChild) {
                        parent.left = current.left;
                    } else {
                        parent.right = current.left;
                    }
                } else if (current.left == null) {
                    if(current == this.root) {
                        this.root = current.right;
                    }
                    // 删除的节点只有一个子节点
                    else if (isLeftChild) {
                        parent.left = current.right;
                    } else {
                        parent.right = current.right;
                    }
                } else {
                    // 删除节点有两个子节点
                    var successor = this.getSuccessor(current);
                    // 判断是否是根节点
                    if(current == this.root) {
                        this.root = successor;
                    } else if(isLeftChild) {
                        parent.left = successor;
                    } else {
                        parent.right = successor;
                    }
                    successor.left = current.left;
                }

            }
            // 找后继的方法
            BinarySearchTree.prototype.getSuccessor = function(delNode) {
                // 定义变量，保存找到的后继
                var successor = delNode;
                var current = delNode.right;
                var successorParent = delNode;
                // 循环查找
                while(current != null) {
                    successorParent = successor;
                    successor = current;
                    current = current.left;

                }
                // 判断循环查找的后继节点是否是delNode的right节点
                if(successor != delNode.right) {
                    successorParent.left =  successor.right;
                    successor.right = delNode.right;
                }
                return successor;
            }
        }

        var bst = new BinarySearchTree();
        bst.insert(11);
        bst.insert(7);
        bst.insert(15);
        bst.insert(5);
        bst.insert(3);
        bst.insert(9);
        bst.insert(8);
        bst.insert(10);
        bst.insert(13);
        bst.insert(12);
        bst.insert(14);
        bst.insert(20);
        bst.insert(18);
        bst.insert(25);

        // var resultString = "";
        // bst.preOrderTraversal(function (key) {
        //     resultString += key + " ";
        // })
        // alert(resultString);

        // var resultString = "";
        // bst.midOrderTraversal(function (key) {
        //     resultString += key + " ";
        // })
        // alert(resultString);

        // var resultString = "";
        // bst.postOrderTraversal(function (key) {
        //     resultString += key + " ";
        // })
        // alert(resultString);

        // alert(bst.min());
        // alert(bst.max());
        // alert(bst.search(2));
        // alert(bst.search(25));

        bst.remove(9);
        bst.remove(7);
        bst.remove(15);
        var resultString = "";
        bst.postOrderTraversal(function (key) {
            resultString += key + " ";
        })
        alert(resultString);