JavaScript数据结构与算法（七）：二叉搜索树

/**
 * BST 二叉搜索树
 */ 

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

    /**
     * insert方法的辅助函数
     * @param {父结点} root 
     * @param {新结点} node 
     */ 
    var insertNode = function(node, new_node) {
        if(new_node.key < node.key) {
            if(node.left === null) {
                node.left = new_node;
            } else {
                insertNode(node.left, new_node);
            }
        } else {
            if(node.right === null) {
                node.right = new_node;
            } else {
                insertNode(node.right, new_node);
            }
        }
    }
    /**
     * 
     * @param {待插入的值} key 
     */ 
    this.insert = function (key) {  
        var newNode = new Node(key);
        if(root === null) {
            root = newNode;
        } else {
            insertNode(root, newNode);
        }
    }
    /**
     * 查询方法
     * @param {待查询的值} key 
     */ 

    this.search = function (key) {  
        searchNode(root, key);
    }
    /**
     * 
     * @param {当前结点} node 
     * @param {待搜索的键} key 
     */ 
    var searchNode = function (node, key) {  
        if(node === null) {
            return false;
        } else {
            if(node.key === key) {
                return true;
            } else if(key < node.key) {
                return searchNode(node.left, key);
            } else {
                return searchNode(node.right, key);
            }
        }
    };
    /**
     * 中序遍历
     * @param {对遍历到的每个结点进行操作} callback 
     */ 
    this.inOrderTraverse = function (callback) {  
        inOrderTraverseNode(root, callback);
    }
    /**
     * 中序遍历的辅助函数
     * @param {*} root 
     * @param {*} callback 
     */ 
    var inOrderTraverseNode = function (node, callback) {  
        if(node !== null) {
            inOrderTraverseNode(node.left, callback);
            callback(node.key);
            inOrderTraverseNode(node.right, callback);
        }
    }
    /**
     * 先序遍历
     * @param {*} callback 
     */ 
    this.preOrderTraverse = function (callback) {  
        preOrderTraverseNode(root, callback);
    }
    /**
     * 先序遍历的辅助函数
     * @param {*} node 
     * @param {*} callback 
     */ 
    var preOrderTraverseNode = function (node, callback) {  
        if(node !== null) {
            callback(node.key);
            preOrderTraverseNode(node.left, callback);
            preOrderTraverseNode(node.right, callback);
        }
    }

    this.postOrderTraverse = function (callback) {  
        postOrderTraverseNode(root, callback);
    }
    /**
     * 先后序遍历的辅助函数
     * @param {*} node 
     * @param {*} callback 
     */ 
    var postOrderTraverseNode = function (node, callback) {  
        if(node !== null) {
            postOrderTraverseNode(node.left, callback);
            postOrderTraverseNode(node.right, callback);
            callback(node.key);
        }
    }
    /**
     * 寻找树的最小值
     */  
    this.min = function () {  
        return minNode(root);
    }
    /**
     * 最小键的辅助函数
     * 树的最左子树叶节点
     * @param {搜最小值} root 
     */ 
    var minNode = function (node) {  
        if(node !== null) {
            while(node && node.left !== null) {
                node = node.left;
            }
            return node.key;
        }
        return null;
    }
    /**
     * 寻找树的最大值
     */  
    this.max = function () {  
        return maxNode(root);
    }
    /**
     * 最小键的辅助函数
     * 树的最右子树的叶节点
     * @param {搜最大值} node 
     */ 
    var maxNode = function (node) {  
        if(node) {
            while(node && node.right !== null) {
                node = node.right;
            }
            return node.right;
        }
        return null;
    }
    /**
     * 
     * @param {删除键} key 
     */ 
    this.remove = function (key) {  
        removeNode(root, key);
    }
    /**
     * 删除结点的辅助函数
     * 注意：待删除结点的位置有多种情况
     */ 
    var removeNode = function (node, key) {  
        if(node === null) {
            return null;
        }
        if(key < node.key) {
            node.left = removeNode(node.left, key);
            return node;
        } else if(key >  node.key) {
            node.right = removeNode(node.right, key);
            return node;
        } else {
            // 待删除结点是叶子结点
            if(node.left === null && node.right === null) {
                node = null;
                return node;
            } 
            // 待删除结点只有一子树（或一个子结点）
            if(node.left === null) {
                node = node.right;
                return node;
            } else if(node.right === null) {
                node = node.right;
                return node;
            }

            // 待删除结点有2个子树
            var aux = findMiNode(node.right);
            node.key = aux.key;
            node.right = removeNode(node.right, aux.key);
            return node;
        }
    }
    /**
     * 找出子树中最小值的结点
     * @param {子树根结点} node 
     */ 
    var findMiNode = function (node) {  
        if(node !== null) {
            while(node && node.left !== null) {
                node = node.left;
            }
            return node;
        }
        return null;
    }
}

module.exports = BinarySearchTree;