二叉树-Javascript实现

部分参考这篇博文

github代码

其实这里写的也就是原代码，学数据结构很难，二叉树各种操作的核心，我目前领悟到的就是递归，递归，递归，学习要学习自己觉得很困难的知识，这样才会有进步。恩，这个鸡汤真馊！！

/**
     *
     * @param val
     * @constructor
     */
    function Node(val, left, right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
    Node.prototype.show = function() {
        return this.val;
    }
    /**
     *
     * @constructor
     */
    function BTree() {
        this.root = null;
        this.depthBT = 0;
    }
    BTree.prototype = {
        constructor : BTree,
        add : function(val){
            // 插入二叉树，找准规律，
            // 1. 二叉树是值小的存放在左子树，值大的存放在右子树
            // 2. 插入的时候，用根节点举例，是当一个节点的左子树或者右子树为空的时候才可以插入
            // 3. 根据特点，可以得出大概思路，首先从根节点出发，判断是在根节点的左边还是右边，假设是在右边
            // 4. 判断根节点的右子树是否为空，如果为空，则把当前值放入右子树
            // 5. 如果不为空，则说明不能插入，需要把这个右子树设置为根节点，继续进行比较
            var newNode = new Node(val, null, null);
            if(!this.root) {
                // 根节点初始化
                this.root = newNode;
            }else {
                var current = this.root,
                    parent;// 保存current的值，表示父节点
                while(current) {
                    parent = current;
                    if(val < current.val) {
                        // 判断是否是底层节点
                        current = current.left;
                        if(current == null ) {
                            parent.left = newNode;
                            return;
                        }
                    }else {
                        current = current.right;
                        if(current == null) {
                            parent.right = newNode;
                            return;
                        }
                    }
                }
            }
        },
        depth : function(node) {
            // 求最大深度，是从最底层升序，即用递归，从顶层根节点向下延伸
            // 到达最底层后，再次调用node.left和node.right，则都return 0
            // 比较ldepth和rdepth，给最大的深度+1，这个1指的是这个子节点本身
            // 向上回溯递归，其实就相当于是比较子节点的深度，然后把自己分配到子节点深度最深的节点链上

            return !node ? 0 : Math.max(this.depth(node.left),this.depth(node.right)) + 1;
//            if(!node) {
//                return 0;
//            }else {
//                var ldepth = this.depth(node.left);
//                var rdepth = this.depth(node.right);
//                return ldepth > rdepth ? ldepth + 1 : rdepth + 1;
//            }
        },
        preorder : function(node) {
            // 举例：只有两层的二叉树23→16→45
            // 传入跟节点，由于先序遍历，直接打印当前节点的node值（23）
            // 传入左子树，作为新的node递归，先打印左子树的值（16），然后用左子树的.left递归，发现为空跳出
            // 左子树的.right递归，发现为空跳出
            // 传入右子树，作为新的node递归，先打印右子树的值（45），然后用右子树的.left递归，发现为空跳出
            // 右子树的.right递归，发现为空跳出

            // 先序遍历
            if(node) {
                console.log(node.show());
                this.preorder(node.left);
                this.preorder(node.right);
            }
        },
        inorderTraversal : function(node) {
            // 中序遍历
            if(node){
                this.inorderTraversal(node.left);
                console.log(node.show());
                this.inorderTraversal(node.right);
            }
        },
        postorderTraversal : function(node) {
            // 后序遍历
            if(node) {
                this.postorderTraversal(node.left);
                this.postorderTraversal(node.right);
                console.log(node.show());
            }
        },
        BFS : function(node) {
            // 1. 用数组模拟队列（先进先出），根节点入栈
            // 2. 只要队列不为空，就打印出队列头
            // 3. 判断节点左右子树是否各自为空，不为空则推入队列中

            // 广度优先遍历
            var nodes = [];

            if(!node) {
                console.log('empty tree');
            }else {
                nodes.push(node);

                while(nodes.length !== 0) {
                    node = nodes.shift();// 队首出栈
                    console.log(node.val);

                    if(node.left) {
                        nodes.push(node.left);
                    }
                    if(node.right) {
                        nodes.push(node.right);
                    }
                }
            }
        },
        searchMin : function(node) {
            // 最小值存储在左子树中，只需要一直访问左子树就可以了

            // 查找最小值
            while(node.left) {
                node = node.left;
            }
            return node;

        },
        searchMax : function(node) {
            // 查找最大值
            while(node.right) {
                node = node.right;
            }
            return node;
        },
        find : function(val) {
            // 需要判断查找值和根节点值的大小，决定继续访问左子树还是右子树

            // 查找指定值
            var node = this.root,
                parent = node;// 保存父节点

            while(node) {
                if(node.val === val) {
                    // 返回父节点对象和查找节点对象
                    return {nodeParent : parent,findNode : node};
                }else{
                    parent = node;
                    if(node.val > val) {
                        node = node.left;
                    }else {
                        node = node.right;
                    }
                }
            }
            return null;
        },
        removeNode : function(val) {
            // 1.删除节点没有子树，为叶子结点，则把父元素指向他的指针置为null
            // 2.删除节点有一个子树，则把父元素指向他的指针指向他的子树
            // 3.删除节点有两个子树，（1）用左子树中的最小值代替删除节点并删除最小值节点 （2）用右子树中的最大值代替删除节点并删除最大值节点

            // 删除节点
            var currentobj = this.find(val),
                parentNode,// 父元素
                currentNode;// 查找元素

            if(currentobj){
                parentNode = currentobj.nodeParent;// 获得父元素
                currentNode = currentobj.findNode;// 获得查找元素

                if(currentNode.left == null && currentNode.right == null){
                    choosePos(null);

                }else if(currentNode.left && currentNode.right){
                    var max = this.searchMax(currentNode.right).val,// 找到最大值节点
                        maxNode = this.find(max);// 找到最大值对象在二叉树中的父元素，以及本身

                    currentNode.val = max;// 将删除的节点的值改成最大值
                    maxNode.nodeParent.right = null;// 删除最大值节点，将最大值节点的父节点指向null

                }else if(currentNode.right){// 右节点存在，左节点不存在
                    choosePos(currentNode.right);
                }else if(currentNode.left) {// 左节点存在，右节点不存在
                    choosePos(currentNode.left);
                }
            }else{
                return '删除节点不再树中';
            }
            // 只是为了获得一个操作句柄，但是不知道怎么处理，只能写了一个方法，很笨
            function choosePos(setValue){
                currentNode.val > parentNode.val ? parentNode.right = setValue : parentNode.left = setValue;
            }
        }
    }

    var bt = new BTree(),
        arrTree = [23,45,16,37,3,4,99,22,44,52,42,10,100,1];

    arrTree.forEach(function(i){
        // 生成二叉树
        bt.add(i);
    });
    console.log(bt);

    console.log('先序');
    bt.preorder(bt.root);
    console.log('中序');
    bt.inorderTraversal(bt.root);
    console.log('后序');
    bt.postorderTraversal(bt.root);

    // 二叉树深度
    console.log(bt.depth(bt.root));

    // 查找二叉树最小值
    console.log('查找最小值 ' + bt.searchMin(bt.root).val);
    // 查找二叉树最大值
    console.log('查找最大值 ' + bt.searchMax(bt.root).val);

    // 查找指定值
    console.log('查找结果父元素的值：' + bt.find(99).nodeParent.val);
    console.log('查找结果的值：' + bt.find(99).findNode.val);

    // 删除节点
    console.log('删除节点之前查找结果父元素：' + bt.find(52).nodeParent.val);
    bt.removeNode(52);
    console.log('删除节点之后查找结果：' + bt.find(52));
    console.log(bt.removeNode(55));

目前实现

• 二叉树插入
• 二叉树最大深度
• 二叉树深度优先遍历（先序，中序，后序）
• 广度优先遍历
• 二叉树查找最大值
• 二叉树查找最小值
• 二叉树查找指定值
• 二叉树删除节点