二叉树 BinaryTree（JavaScript）

本文用JavaScript实现了对二叉树的相关操作，包括：创建二叉树，对二叉树进行先序遍历，中序遍历，后序遍历，以及从二叉树中查找最大值，最小值，指定值。

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

        var root = null;

        var insertNode = function (node,newNode) {
            if(newNode.key < node.key){
                if(node.left === null){
                    node.left = newNode ;
                }else {
                    insertNode(node.left,newNode);
                }
            }else {
                if(node.right === null){
                    node.right = newNode;
                }else {
                    insertNode(node.right,newNode);
                }
            }
        };
        //创建节点、并插入到合适的位置
        this.insert = function (key) {
            var newNode = new Node(key);
            if(root == null){
                root = newNode;
            }else {
                insertNode(root,newNode);
            }
        };

        //中序遍历(结果为升序排列)
        var  inOrderTraverseNode = function (node,callback) {
            if(node !== null){
                inOrderTraverseNode(node.left,callback);
                callback(node.key);
                inOrderTraverseNode(node.right,callback);
            }
        };

        this.inOrderTraverse = function (callback) {
            inOrderTraverseNode(root,callback);
        };

        //前序遍历（复制一棵二叉树、效率高）
        var preOrderTraverseNode = function (node,callback) {
            if(node !== null){
                callback(node.key);
                preOrderTraverseNode(node.left,callback);
                preOrderTraverseNode(node.right,callback);
            }
        };

        this.preOrderTraverse = function (callback) {
            preOrderTraverseNode(root,callback);
        };

        //后序遍历（遍历文件系统）
        var postOrderTraverseNode = function (node,callback) {
            if(node !== null){
                postOrderTraverseNode(node.left,callback);
                postOrderTraverseNode(node.right,callback);
                callback(node.key);
            }
        };

        this.postOrderTraverse = function (callback) {
            postOrderTraverseNode(root,callback);
        };

        //二叉排序树的查找
        //1. 找最小值：从根节点开始一直找左孩子，直到某个节点没有左孩子，则该节点的值即为最小值
        //2. 找最大值：从根节点开始一直找右孩子，直到某个节点没有右孩子，则该节点的值即为最大值
        //注：左子树的所有节点的值都比该节点小，右子树的所有节点的值都比该节点大

        var minNode = function (node) {
            if(node){
                while (node && node.left !== null) {
                    node = node.left;
                }
                return node.key;
            }
            return null;
        };

        this.min = function () {
            return minNode(root);
        };

        var maxNode = function (node) {
            if(node){
                while (node && node.right !== null) {
                    node = node.right;
                }
                return node.key;
            }
            return null;
        }

        this.max = function () {
            return maxNode(root);
        };

        var searchNode = function (node,key) {
            if(node === null){
                return false;
            }
            if(key < node.key){
                return searchNode(node.left,key);
            }else if (key > node.key) {
                return searchNode(node.right,key);
            }else {
                return true;
            }
        };

        this.search = function (key) {
            return searchNode(root,key);
        };

        var findMinNode = function (node) {
            if (node) {
                while (node && node.left !== null) {
                    node = node.left;
                }
                return node;
            }
            return null;
        };

        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.left;
                    return node;
                }

                var aux = findMinNode(node.right);
                node.key = aux.key;
                node.right = removeNode(node.right,aux.key);
                re
            }
        };

        this.remove = function (key) {
            return removeNode(root,key);
        };



    }


    var nodes = [8, 3, 10, 1, 6, 14, 4, 7, 13];
    var BinaryTree = new BinaryTree();
    nodes.forEach(function(key){
        BinaryTree.insert(key);
    });

    var callback = function (key) {
        console.log(key);
    }
//    BinaryTree.postOrderTraverse(callback);
//    console.log("the min is: " + BinaryTree.min());
//    console.log("max node is: " + BinaryTree.max());
//    console.log( BinaryTree.search(9));
      BinaryTree.remove(1);
      console.log(BinaryTree.inOrderTraverse(callback));