红黑树的java实现

public class RbTree<K extends Comparable,V> {
    
    /** 跟节点 */
    private Entity<K,V> root;

    /** 数量 */
    private int size = 0;


    /**
     * 增加节点<br>
     * @param key 键
     * @param vaule 值
     */
    public void addNode(K key,V vaule){
        if(Objects.isNull(key)){
            return;
        }
        if(root == null){
            Entity node = new Entity(key,vaule);
            root = node;
            root.color=true;
            size++;
            return;
        }
        Entity currentNode = root;
        Entity parentNode = root;
        int compare = 0;
        while(currentNode != null){
            parentNode = currentNode;
            if((compare = currentNode.key.compareTo(key)) > 0){
                currentNode = currentNode.left;
            }else if(compare < 0){
                currentNode = currentNode.right;
            }else{
                //相等重新赋值
                currentNode.setVal(vaule);
                return;
            }
        }
        Entity node = new Entity(key,vaule,parentNode);
        if(compare >0){
            parentNode.left = node;
        }else{
            parentNode.right = node;
        }
        insertFixup(node);
        size++;
    }

    /**
     * 根据key删除节点
     * @param key
     */
    public void delNode(K key){
        if(Objects.isNull(key)){
            System.out.println("key不能为空");
            return;
        }
        Entity dNode = findNode(key);
        if(Objects.isNull(dNode)){
            System.out.println("key不存在："+key);
            return;
        }
        if(Objects.nonNull(dNode.left) && Objects.nonNull(dNode.right)){
            Entity p = successor(dNode);
            if(p != null){
                dNode.key = p.key;
                dNode.val = p.val;
                dNode = p;
            }
        }
        //替换节点
        Entity replaceNode = dNode.left != null ? dNode.left : dNode.right;
        if(Objects.nonNull(replaceNode)){
            replaceNode.parent = dNode.parent;
            if(replaceNode.parent == null){
                root = replaceNode;
            }else if(dNode == leftOf(dNode.parent)){
                dNode.parent.left =  replaceNode;
            }else{
                dNode.parent.right =  replaceNode;
            }
            dNode.val = dNode.parent = null;
            dNode.key = null;
            //黑色节点
            if(dNode.color){
                delFixup(replaceNode);
            }
        }else if(dNode.parent == null){
            root = null;
        }else{
            //黑色节点
            if(dNode.color){
                delFixup(dNode);
            }
            if(dNode == leftOf(dNode.parent)){
                dNode.parent.left = null;
            }else{
                dNode.parent.right = null;
            }
            dNode.parent = null;
            dNode.key = null;
            dNode.val = null;
        }


    }

    private void delFixup(Entity dNode){
        while(dNode != root && dNode.color){
            if(leftOf(parentOf(dNode)) == dNode){
                Entity sib = rightOf(parentOf(dNode));
                if(!sib.color){
                    sib.color = true;
                    parentOf(dNode).color = false;
                    leftRotate(parentOf(dNode));
                    sib = parentOf(dNode).right;
                }
                if(leftOf(sib).color && rightOf(sib).color){
                    sib.color = false;
                    dNode = dNode.parent;
                }else{
                    if(!leftOf(sib).color){
                        sib.color = false;
                        rightOf(sib).color = true;
                        rightRotate(sib);
                        sib = sib.parent;
                    }
                    rightOf(sib).color = true;
                    leftRotate(dNode.parent);
                    boolean color = dNode.parent.color;
                    dNode.parent.color = dNode.parent.parent.color;
                    dNode.parent.parent.color=color;
                    dNode = root;
                }
            }else{
                //获取兄弟节点
                Entity sib = leftOf(parentOf(dNode));
                //如果兄弟节点为红色
                if(!colorOf(sib)){
                    dNode.parent.color = false;
                    sib.color = true;
                    rightRotate(parentOf(dNode));
                    sib = leftOf(parentOf(dNode));
                }
                //兄弟和子节点全部是黑色
                if(rightOf(sib).color && leftOf(sib).color){
                    sib.color = false;
                    dNode = dNode.parent;
                }else{
                    if(!rightOf(sib).color){
                        rightOf(sib).color = true;
                        sib.color = false;
                        leftRotate(sib);
                        sib = sib.parent;
                    }
                    leftOf(sib).color = true;
                    rightRotate(dNode.parent);
                    boolean color = dNode.parent.color;
                    dNode.parent.color = dNode.parent.parent.color;
                    dNode.parent.parent.color=color;
                    dNode = root;
                }
            }
        }
        //当替换节点为红色是直接改成黑色即可
        dNode.color = true;
    }
    private Entity successor(Entity dNode){
        if(dNode == null){
            return null;
        }else if(Objects.nonNull(dNode.right)){
            Entity node = dNode.right;
            while(Objects.nonNull(node.left)){
                node = node.left;
            }
            return node;
        }else{
            return null;
        }
    }
    /**
     * 根据key查询节点 <br/>
     * @param key
     * @return
     */
    private Entity findNode(K key){
        if(root == null){
            return null;
        }
        Entity current = root;
        int compare = 0;
        while(current != null){

            if((compare = current.key.compareTo(key)) > 0){
                current = current.left;
            }else if(compare < 0){
                current = current.right;
            }else{
                return current;
            }
        }
        return null;
    }
    /**
     * 插入修正<br/>
     * @param  node 插入节点
     *
     */
    private void insertFixup(Entity node){
        if(Objects.isNull(node.parent)){
            node.color = true;
        }else if(!node.parent.color){//父节点为红色
            //父节点
            Entity p = parentOf(node);
            Entity pp = pparentOf(node);
            //父节点是左节点
            if(leftOf(pp) == p){
                if(!colorOf(rightOf(pp))){
                    p.color=true;
                    rightOf(pp).color = true;
                    pp.color=false;
                    insertFixup(pp);
                }else{
                    if(rightOf(p) == node){
                        leftRotate(p);
                        node = p;
                    }
                    parentOf(node).color = true;
                    pp.color = false;
                    rightRotate(pp);
                }

            }else{//是右节点
                if(!colorOf(leftOf(pp))){
                    p.color=true;
                    leftOf(pp).color= true;
                    pp.color = false;
                    insertFixup(pp);
                }else{
                    if(leftOf(p) == node){
                        rightRotate(p);
                        node = p;
                    }
                    parentOf(node).color = true;
                    pp.color = false;
                    leftRotate(pp);
                }
            }
        }else{
            //NO LOOP 父节点为黑色不操作
        }
    }


    /**
     * 返回节点颜色
     * @param node
     * @return
     */
    private Boolean colorOf(Entity node){
        return node == null?true:node.color;
    }

    /**
     * 返回左节点
     * @param node
     * @return
     */
    private Entity leftOf(Entity node){
        return node == null?null:node.left;
    }

    /**
     * 返回右节点
     * @param node
     * @return
     */
    private Entity rightOf(Entity node){
        return node == null?null:node.right;
    }
    /**
     *
     * @param node
     * @return
     */
    private Entity parentOf(Entity node){
        return node == null?null:node.parent;
    }
    /**
     *
     * @param node
     * @return
     */
    private Entity pparentOf(Entity node){
        return parentOf(parentOf(node));
    }
    /**
     * 左旋转<br/>
     * @param node 节点
     */
    private void leftRotate(Entity node){
        Entity rightNode = node.right;
        if (rightNode == null){
            return;
        }
        Entity rightLeftNode = rightNode.left;
        node.right = rightLeftNode;
        if(Objects.nonNull(rightLeftNode)){
            rightLeftNode.parent = node;
        }
        if(node.parent != null){
            if(node.parent.left == node){
                node.parent.left = rightNode;
            }else{
                node.parent.right = rightNode;
            }
        }else{
            root = rightNode;
        }
        rightNode.parent = node.parent;
        node.parent = rightNode;
        rightNode.left = node;
    }

    /**
     * 右旋转<br/>
     * @param node 节点
     */
    private void rightRotate(Entity node){
        //左节点
        Entity left = node.left;
        if(left == null){
            return;
        }
        Entity leftRightNode = left.right;
        node.left = leftRightNode;
        if(Objects.nonNull(leftRightNode)){
            leftRightNode.parent = node;
        }
        if(node.parent == null){
            root = left;
        }else{
            if(node.parent.left == node){
                node.parent.left = left;
            }else{
                node.parent.right = left;
            }
        }
        left.parent = node.parent;
        left.right = node;
        node.parent = left;

    }
    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    static class Entity<K extends Comparable,V>{

        Entity(K key,V val){
            this.key = key;
            this.val = val;
        }
        Entity(K key,V val,Entity parent){
            this.key = key;
            this.val = val;
            this.parent = parent;
        }
        private K key;

        private V val;

        private Entity left;

        private Entity right;

        private Entity parent;

        /** true：黑色  false：红色 默认红色*/
        private boolean color = false;
        public Object getVal() {
            return val;
        }

        public K getKey() {
            return key;
        }

        public void setKey(K key) {
            this.key = key;
        }

        public void setVal(V val) {
            this.val = val;
        }

        public boolean isColor() {
            return color;
        }

        public void setColor(boolean color) {
            this.color = color;
        }

        public Entity getLeft() {
            return left;
        }

        public void setLeft(Entity left) {
            this.left = left;
        }

        public Entity getRight() {
            return right;
        }

        public void setRight(Entity right) {
            this.right = right;
        }

        public Entity getParent() {
            return parent;
        }

        public void setParent(Entity parent) {
            this.parent = parent;
        }
    }

转载于:https://my.oschina.net/u/2504004/blog/3021847