二叉树

最新推荐文章于 2022-07-09 13:48:50 发布
chunxian1070
最新推荐文章于 2022-07-09 13:48:50 发布
阅读量68
点赞数
文章标签：数据结构与算法 javascript ViewUI
原文链接：https://my.oschina.net/u/3706777/blog/1550505
版权
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>removeNode</title>
</head>
<body>
<h1>删除值</h1>
<p></p>
<script type="text/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);
//            console.log(root)
        }

        //前序遍历方法
        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);
        }

        //查找最小值方法
        var minNode = function(node){
            if(node){
                while(node && node.left !== null){  //当前节点存在且其左节点不为空时继续循环
                    node = node.left;
                }
                return node.key;
            }
        }
        //查找最小值
        this.min = function(){
            return minNode(root);
        }

        //查找最大值方法
        var maxNode = function(node){
            if(node){
                while(node && node.right !== null){
                    node = node.right;
                }
                return node.key;
            }
        }
        //查找最大值
        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);
                return node;
            }
        }
        //叶子节点的删除及原理
        this.remove = function(key){
            root = removeNode(root,key);  //重置二叉树
        }

    }
    var nodes= [8,3,10,1,6,14,4,7,13];
    var binartyTree = new BinaryTree();
    nodes.forEach(function(key){
        binartyTree.insert(key);
    });
    //打印输出相应的值
    var callback = function(key){
        console.log(key);  //打印的值是升序排列
    };
//    binartyTree.inOrderTraverse(callback); //中序遍历
//    binartyTree.preOrderTraverse(callback);  //前序遍历
//    binartyTree.postOrderTraverse(callback);  //后序遍历

    console.log("查找的最小值是："+ binartyTree.min());
    console.log("查找的最大值是："+ binartyTree.max());
    console.log(binartyTree.search(9));
    binartyTree.remove(3);
</script>

</body>
</html>
转载于:https://my.oschina.net/u/3706777/blog/1550505