二叉查找树的操作

最新推荐文章于 2023-09-17 08:57:12 发布
原创最新推荐文章于 2023-09-17 08:57:12 发布 · 199 阅读
0 ·
CC 4.0 BY-SA版权
javascript 同时被 3 个专栏收录
15 篇文章
订阅专栏
算法
6 篇文章
订阅专栏
数据结构与算法
5 篇文章
订阅专栏
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>二叉查找树</title>
</head>
<body>
    <script type="text/javascript">
        function inOrderTraverse(bTree) {
            if(bTree!=null)
            {
                inOrderTraverse(bTree.left);
                console.log(bTree.key);
                inOrderTraverse(bTree.right);
            }
        }

        function preOrderTraverse(bTree,callback) {
            if(bTree!=null)
            {
                bt.insert(bTree.key);
                preOrderTraverse(bTree.left);
                preOrderTraverse(bTree.right);
            }
        }

        function lastOrderTraverse(bTree) {
            if(bTree!=null)
            {
                lastOrderTraverse(bTree.left);
                lastOrderTraverse(bTree.right);
                console.log(bTree.key);
            }
        }

        function  BinaryTree() {

            //节点对象  传递一个key
            var Node=function (key) {
                this.key=key;
                this.left=null;
                this.right=null;
            }

            //根节点
            this.root=null;

            //插入节点
            this.insert=function (key) {
                var node=new Node(key);
                //根节点不存在 新建节点为根节点
                if(this.root==null)
                {
                    this.root=node;
                }
                else
                {
                    var rootT=this.root;
                    this.insertNode(rootT,key);
                }
            }

            //插入节点
            this.insertNode=function (fRoot,fKey) {
                //如果插入的值小于根节点的的值
                if(fKey<fRoot.key)
                {
                    if(fRoot.left==null)
                    {
                        var fNode=new Node(fKey);
                        fRoot.left=fNode;
                    }
                    else
                    {
                        this.insertNode(fRoot.left,fKey);
                    }
                }
                else
                {
                    if(fRoot.right==null)
                    {
                        var fNode=new Node(fKey);
                        fRoot.right=fNode;
                    }
                    else
                    {
                        this.insertNode(fRoot.right,fKey);
                    }
                }
            }

            //中序遍历
            this.inOrderTraverse=function inOrderTraverse(node) {
                if(arguments.length==0)
                {
                    node=this.root;
                }
                if(node!=null)
                {
                    inOrderTraverse(node.left);
                    console.log(node.key);
                    inOrderTraverse(node.right);
                }
            }

            //先序遍历
            this.preOrderTraverse=function preOrderTraverse(node) {
                if(arguments.length==0)
                {
                    node=this.root;
                }
                if(node!=null)
                {
                    console.log(node.key);
                    preOrderTraverse(node.left);
                    preOrderTraverse(node.right);
                }
            }

            //后序遍历
            this.postOrderTraverse=function postOrderTraverse(node) {
                if(arguments.length==0)
                {
                    node=this.root;
                }
                if(node!=null)
                {
                    lastOrderTraverse(node.left);
                    lastOrderTraverse(node.right);
                    console.log(node.key);
                }
            }

            //最小值
            this.min=function min (node) {
                if(arguments.length==0){
                    node=this.root;
                }

                if(node&&(node.left!==null))
                {
                    return min(node.left);
                }
                else
                {
                    console.log(node);
                    return node;
                }
            }

            //最大值
            this.max=function max(node) {
                if(arguments.length==0)
                {
                    node=this.root;
                }
                if((node) && (node.right!==null))
                {
                    return max(node.right);
                }
                else
                {
                    return node;
                }
            }

            //查找节点
            this.search=function search() {
                if(arguments.length==1)
                {
                    node=this.root;
                    key=arguments[0];
                    console.log(key);
                }
                else if(arguments.length==2)
                {
                    node=arguments[0];
                    key=arguments[1];
                }

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



            }

            //查找节点
            function searchR(node) {
                if(node.left!==null)
                {
                    return node.left;
                }
                else
                {
                    return node;
                }
            }

            //删除节点
            this.removeNode=function removeNode (node,key) {
                if(node===null)
                {
                    return null;
                }
                //要删除的节点在 左侧
                if(node.key>key)
                {
                    //不为空  递归到左子树
                    if(node.left!==null)
                    {
                        node.left=  removeNode(node.left,key);
                        return node;
                    }
                    //返回错误
                    return false;
                }
                else if(node.key<key)
                {
                    //不为空  递归到右子树
                    if(node.right!==null)
                    {
                        node.right=removeNode(node.right,key);
                        return node;
                    }
                    //返回错误
                    return false;
                }
                else
                {
                    //找到要删除的节点  1 要删除的节点没有左右字树 2只有右字树
                    if((node.left===null) && (node.right==null))
                    {
                        node.key=null;
                        return node;
                    }
                    if(node.left===null)
                    {
                        node=node.right;
                        return node;
                    }
                    else if(node.right==null)
                    {
                        node=node.left;
                        return node;
                    }
                    else
                    {
                        var sNode= searchR(node.right);
                        node.key=sNode.key;
                        console.log(sNode);
                        node.right=removeNode(node.right,sNode.key);
                        return node;
                    }


                }
            }

        }

        var bt=new BinaryTree();

        var bTree=new BinaryTree();

        var nodes=[5,6,2,1,3,13,45,12,22];
        //生成一个二叉树
        nodes.forEach(function (t) {
            bTree.insert(t);
        });
        //console.log(bTree);


        console.log(bTree);

        //二叉树的中序遍历
        //bTree.inOrderTraverse();



        //先序遍历
        //preOrderTraverse(bTree.root,bt);

        //console.log(bt);
        //后序遍历

        //bTree.postOrderTraverse();

//        var minNode= bTree.min();
//        console.log(minNode.key);
//
//        var maxNode=bTree.max();
//        console.log(maxNode.key);


            //var searchT=bTree.search(66);
            //console.log(searchT);

           var nnode=bTree.removeNode(bTree.root,13);
           console.log(nnode);

           console.log(bTree);

    </script>
</body>
</html>