数据结构-二叉树

二叉树

二叉树的特点是，如果当前节点比根节点大则放在根节点的右边，否则放在左边；

创建二叉树节点

         function Node(element, left, right) {
            this.element = element;
            this.left = left;
            this.right = right;
            this.show = function () {
                return this.element;
            };
        }

          function BST() {
            this.root = null;
            }

1.插入数据

二叉树的数据插入相比较而言是有点复杂的，需要判断的条件很多，需要挨个进行分析：

如插入一段数据：23,45,16,37,3,99,22

插入之后应该如图显示：

           this.insert = function (element) {
            //1， 创建新节点
            var node = new Node(element, null, null,null);
            if (this.root == null) {
                this.root = node;
            } else {
                //设置父节点
                var parent = this.root;
                while (true) {
                    var buffer = parent;
                    if (node.element > parent.element) {
                        //和根节点的右边节点进行比较
                        parent = parent.right;
                        if (parent == null) {
                            node.parent = buffer;
                            buffer.right = node;
                            break;
                        }
                    } else {
                        //和根节点的左边节点进行比较
                        parent = parent.left;
                        if (parent == null) {
                            node.parent = buffer;
                            buffer.left = node;
                            break;
                        }

                    }
                }
            }
        }

2.查找节点、最大值、最小值

查找最大值与最小值，根据二叉树插入数据的特性可知，查找最小值只需不断查找左边的节点，直至左节点为空，最大值同理

         //查找节点
        this.find = function (element) {
            var node = this.root;
            while (true) {
                if (node == null)
                    return node;
                if (node.element == element) {
                    return node;
                } else if (element < node.element) {
                    node = node.left;
                } else if (element > node.element) {
                    node = node.right;
                }
            }
        }

        // 查找最小值
        this.getMin = function (element) {
            var node = this.find(element);
            // console.log(node);
            while (node.left != null) {
                node = node.left;
            }
            return node;
        }

        // 查找最大值
        this.getMax=function (element) {
            //找到当前节点
            var node=this.find(element);
            while(node.right!=null){
                node=node.right;
            }
            return node;
        }

3.删除节点

二叉树删除节点的原理是将当前节点删除，并将当前节点的右节点移到当前节点的位置上，当前节点的左节点则移动到右节点的最小节点上；

如删除节点45：因为45节点的右边节点为99，而99并没有左边节点，那么37节点则添加到99的左边节点上；

删除16：

删除根节点23：删除根节点之后45作为根节点，23的左节点，变成45左边节点的左节点

代码如下：

         //删除节点
         this.remove = function (element) {
            //获得当前节点
            var node = this.find(element);
            if (node == null)
                return;
            // 判断当前节点是否为根节点
            if (node.parent == null) {
                //如果为根节点则，找根节点的右节点
                if (node.right != null) {
                    this.root = node.right;
                    this.root.parent = null;
                    //获得根节点的右节点的最小节点
                    var minNode = this.getMin(node.right.element);
                    minNode.left = node.left;
                    node.left.parent=minNode;
                } else {
                    this.root = node.left;
                    this.root.parent = null;
                }

            }else{
                //如果不为根节点，则与根节点的算法一致
                // 找到当前节点的父节点                
                var parent = node.parent;
                //判断当前节点是父节点的右边节点还是左边节点
                // 如果当前节点的值大于父节点，则为右边节点
                if(node.element>parent.element){

                    if(node.right!=null){
                        var minNode = this.getMin(node.right.element);
                        minNode.left=node.left;
                        node.left.parent=minNode;
                        parent.right=node.right;
                        node.right.parent=parent;
                    }else{
                        parent.right=node.left;

                        if(node.left!=null)
                            node.left.parent=parent;
                    }

                }else{
                    // 如果当前节点的值大于父节点，则为左边节点
                    if(node.right!=null){
                        var minNode = this.getMin(node.right.element);
                        minNode.left=node.left;
                        node.left.parent=minNode;

                        parent.left=node.right;
                        node.right.parent=parent;
                    }else{
                        parent.left=node.left;
                        if(node.left!=null)
                            node.left.parent=parent;
                    }
                }
            }
        }