JavaScript数据结构——树（Tree）

概念和结构

• 树由若干节点组成。
• 每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树。
• 我们这里实现二叉搜索树。二叉搜索树，它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树。

二叉搜索树的操作

二叉搜索树有七种常用操作，分别为

1. 插入节点 insert（value）
2. 查找节点 search（value）
3. 移除节点 remove（value）
4. 遍历节点 traverse（value）
5. 获取最小值 min()
6. 获取最大值 max()
7. 获取根节点 getRoot()

JS实现二叉树

JS里面的树结构需要通过对象（object）来实现。

var Tree = function(){
    //辅助类
    function Node(value){
        this.value = value;
        this.left = null;
        this.right = null;
    }

    //根节点
    var root = null;

    //插入节点
    this.insert = function(value){
        var newNode = new Node(value);
        if(root === null){
            root = newNode;
        }else{
            insertNode(root , newNode);
        }
    }
    //插入节点需要用到的函数
    function insertNode(node , newNode){
        if(newNode.value > node.value){
            //往右走
            if(node.right === null){
                node.right = newNode;
            }else{
                insertNode(node.right , newNode);
            }
        }else if(newNode.value < node.value){
            //往左走
            if(node.left === null){
                node.left = newNode;
            }else{
                insertNode(node.left , newNode);
            }
        }
    }

    //查找节点
    this.search = function(value){
        return search(root , value);
    }
    function search(node , value){
        if(node === null){
            return null;
        }else{
            if(value > node.value){
                //向右走
                return search(node.right , value);
            }else if(value < node.value){
                //向左走
                return search(node.left , value);
            }else{
                //返回这个节点
                return node;
            }
        }
    }

    //移除节点
    this.remove = function(value){
        root = removeNode(root , value);
    }
    //移除节点需要用到的函数
    function removeNode(node , value){
        //如果节点为空，返回null
        if(node === null){
            return null;
        }else{
            if(value > node.value){
                //向右走
                node.right = removeNode(node.right , value);
                return node;
            }else if(value < node.value){
                //向左走
                node.left = removeNode(node.left , value);
                return node;
            }else{
                //移除这个节点

                //叶节点    
                if(node.left === null && node.right === null){
                    return null;
                }

                //只有一个子节点的节点
                if(node.left !== null && node.right === null){
                    return node.left;
                }else if(node.left === null && node.right !== null){
                    return node.right;
                }

                //有两个子节点的节点，将这个节点值替换为右侧子树最小子节点值
                var rightMinValue = findMinNode(node.right);
                node.value = rightMinValue;
                node.right = removeNode(node.right , rightMinValue);
                return node;
            }
        }
    }
    //移除节点函数需要用到的寻找最小子节点函数
    function findMinNode(node){
        if(node === null){
            return null;
        }else{
            while(node.left){
                node = node.left;
            }
            return node.value;
        }
    }

    //遍历节点
    this.traverse = function(callback){
        traverse(root , callback);
    }
    //遍历节点需要用到的函数
    function traverse(node , callback){
        //节点为空则返回
        if(node === null){
            return;
        }else{
            // callback(node.value);       //前序遍历
            traverse(node.left , callback);
            // callback(node.value);       //中序遍历
            traverse(node.right , callback);
            callback(node.value);       //后序遍历
        }   
    }

    //获取最小值
    this.min = function(){
        return min(root);
    }
    //获取最小值需要用到的函数
    function min(node){
        //树为空返回null
        if(node === null){
            return null;
        }else{
            while(node.left){
                node = node.left;
            }
            return node.value;
        }
    }

    //获取最大值
    this.max = function(){
        return max(root);
    }
    //获取最大值需要用到的函数
    function max(node){
        //树为空返回null
        if(node === null){
            return null;
        }else{
            while(node.right){
                node = node.right;
            }
            return node.value;
        }
    }

    //获取根节点
    this.getRoot = function(){
        return root;
    }
}