自己动手实现java数据结构（六）二叉搜索树

   
     * target 和目标节点的相对位置
     * enum RelativePosition {
        
         * 左节点
         * 
        LEFT,
         * 右节点
         * 
        RIGHT,1)">
         * 当前节点
         * 
        CURRENT;
    }

 　　
     * 查找目标节点 返回值
     * class TargetEntryNode<K,1)">
         * 目标节点
         *  target;

        
         * 目标节点的双亲节点
         *  parent;

        
         * 相对位置
         * private RelativePosition relativePosition;

        TargetEntryNode(EntryNode<K,V> target,EntryNode<K,1)"> parent,RelativePosition relativePosition) {
            this.target = target;
             parent;
            this.relativePosition = relativePosition;
        }
    }

 　　
     * 获得key对应的目标节点
     *  key   对应的key
     *       对应的目标节点
     *               返回null代表 目标节点不存在
     * private TargetEntryNode<K,1)"> getTargetEntryNode(K key){
        int compareResult = 0;
        EntryNode<K,V> parent = this.root;
        while(currentNode != ){
            parent = currentNode;
            //:::当前key 和 currentNode.key进行比较
            compareResult = compare(key,currentNode.key);
            if(compareResult > 0){
                :::当前key 大于currentNode 指向右边节点
                currentNode = currentNode.right;
            }else if(compareResult < 0:::当前key 小于currentNode 指向右边节点
                currentNode = currentNode.left;
            }else{
                return new TargetEntryNode<>(currentNode,parent,RelativePosition.CURRENT);
            }
        }

        :::没有找到目标节点
        ){
            :::返回 右孩子 哨兵节点
            new TargetEntryNode<>(,RelativePosition.RIGHT);
        }:::返回 左孩子 哨兵节点
            {
            throw new RuntimeException("状态异常");
        }
    }

    
     * key值进行比较
     * 
    @SuppressWarnings("unchecked")
     compare(K k1,K k2){
        :::迭代器不存在
        if(this.comparator == :::依赖对象本身的 Comparable，可能会转型失败
             ((Comparable) k1).compareTo(k2);
        }:::通过迭代器逻辑进行比较
            .comparator.compare(k1,k2);
        }
    }

 　　
     * 判断双亲节点和目标节点 相对位置
     *  parent    双亲节点
     *  target    目标节点
     *           相对位置(左孩子/右孩子)
     private RelativePosition getRelativeByParent(EntryNode<K,V> parent,1)"> target){
        if(parent.left == target){
             RelativePosition.LEFT;
        }if(parent.right == RelativePosition.RIGHT;
        }new RuntimeException("不是父子节点关系"
     * 获得当前节点的直接后继
     *  targetEntryNode     当前节点
     *               当前节点的直接后继
      targetEntryNode){
        if(targetEntryNode == :::当前节点为null，则后继也为null
            ;
        }

        :::判断当前节点是否存在右孩子
        if(targetEntryNode.right != :::存在右孩子，右子树的最左节点为直接后继
            EntryNode<K,V> rightChildSuccessor = targetEntryNode.right;

            :::循环往复，直至直接右孩子的最左节点
            while(rightChildSuccessor.left != ){
                rightChildSuccessor = rightChildSuccessor.left;
            }

             rightChildSuccessor;
        }:::不存在右孩子，寻找第一个靠右的双亲节点
            EntryNode<K,V> parent = targetEntryNode.parent;
            EntryNode<K,V> child = targetEntryNode;

            :::判断当前孩子节点是否是双亲节点的左孩子
            while(parent != null && parent.right == child){
                :::不是左孩子，而是右孩子，继续向上寻找
                child = parent;
                parent = parent.parent;
            }

             parent;
        }
    }
    
    
     * 获得二叉搜索树的第一个节点
     *  getFirstNode(){
        this.root == :::空树，返回null
            ;
        }

        EntryNode<K,V> entryNode = .root;

        :::循环往复，寻找整棵树的最左节点(最小节点、第一个节点)
        while(entryNode.left != ){
            entryNode = entryNode.left;
        }
         entryNode;
    }

3.4?二叉搜索树插入接口实现

　　二叉搜索树的插入接口复用了前面提到的getTargetEntryNode方法，以二分查找的方式进行查询。

　　当key值对应的目标节点存在时，替换掉之前的value。

（编辑：东莞站长网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!