红黑树插入节点

什么是红黑树

红黑树是带有着色性质的二叉查找树。

性质如下:
① 每一个节点或者着成红色或者着成黑色。
② 根节点为黑色。
③ 每个叶子节点为黑色。(指的是指针指向为NULL的叶子节点)
④ 如果一个节点是红色的,那么它的子节点必须是黑色的。
⑤ 从一个节点到一个NULL指针的每一条路径必须包含相同数目的黑色节点。
推论: 有n个节点的红黑树的高度最多是2log(N+1) 。

红黑树旋转操作的原理

下述代码注释搭配图片便于理解

右旋操作:

《红黑树插入节点》 1.jpg

说明:将rbn节点和c节点顺时针旋转到b的下面,然后调整位置。
代码实现:

//顺时针右旋  
public static void rotateByRight(RBNode rbn){  
    RBNode b =rbn.getLchild();  
    //旋转后结果调整,rbn的左孩子为e  
    rbn.setLchild(b.getRchild());  
    //如果b的右孩子e存在就确定e的父节点为rbn  
    if(b.getRchild() !=null){  
        b.getRchild().setParent(rbn);  
    }  
    //确定b的父节点为原rbn的父节点  
    b.setParent(rbn.getParent());  
    if(rbn.getParent() ==null){  
        root =;  
    }else{  
        //确定rbn是否为父节点的右孩子节点  
        if(rbn ==rbn.getParent().getRchild()){  
            rbn.getParent().setRchild(b);  
        }else{  
            rbn.getParent().setLchild(b);  
        }  
    }  
    //确定b的右孩子为rbn  
    b.setRchild(rbn);  
    //确定rbn的父节点为b  
    rbn.setParent(b);  
}  

左旋操作:

《红黑树插入节点》 2.jpg

说明:将rbn节点和c节点逆时针旋转到d的下面,然后调整位置。

代码实现:

//逆时针左旋  
public static void rotateByLeft(RBNode rbn){  
    RBNode d =rbn.getRchild();  
    //确定rbn的右孩子为e  
    rbn.setRchild(d.getLchild());  
    //如果e不为空,那么确定e的父节点为rbn  
    if(d.getLchild() !=null){  
        d.getLchild().setParent(rbn);  
    }  
    //确定d的父节点为rbn的父节点  
    d.setParent(rbn.getParent());  
    if(rbn.getParent() ==null){  
        root =;  
    }else{  
        //确定rbn是否为其父节点的左孩子节点,目得是为了确定d的父节点的左孩子还是右孩子为d  
        if(rbn ==rbn.getParent().getLchild()){  
            rbn.getParent().setLchild(d);  
        }else{  
            rbn.getParent().setRchild(d);  
        }  
    }  
    //确定d的左孩子为rbn  
    d.setLchild(rbn);  
    //确定rbn的父节点为d  
    rbn.setParent(d);  
}  

红黑树插入元素的原理

关于红黑树插入节点后为了保持红黑树的特性,主要进行的操作就是换颜色和旋转操作。

情况1:父节点是黑色,插入新节点为红色。

《红黑树插入节点》 3.png

解决办法:
由于新节点父节点为黑色,直接插入即可。

情况2:父节点为红色,叔叔节点为红色,插入新节点为红色,插入新节点为父节点的左孩子节点。(红叔左父左插入情况)

《红黑树插入节点》 4.png

解决办法:

为了保持新节点为红色,如果此时父节点为红色就不满足性质4.所以父节点需要调整为黑色,但是这样祖节点到NL叶子节点,就会出现数目不同的黑色节点了。不满足性质5了。所以祖节点需要调整为红色节点满足性质。这样叔叔也就得调整为黑色了,要不就不满足性质4和性质5.

总结:
红父->黑父 红叔->黑叔 黑祖->红祖

情况3:父节点为红色,叔叔节点为红色,插入新节点为红色,插入新节点为父节点的右孩子节点。(红叔左父右插入情况)

《红黑树插入节点》 5.png

解决办法:

这种情况同情况2一样,无须旋转,只是颜色不满足性质,只需调整颜色即可。

总结:
红父->黑父 红叔->黑叔 黑祖->红祖

情况4:父节点为红色,叔叔节点为黑色,插入新节点为红色,插入新节点为父节点的左孩子节点。(黑叔左父左插入情况)

《红黑树插入节点》 6.png

解决办法:

这种情况单纯通过换色是无法控制红黑树性质的满足。通过右旋来满足平衡条件。

总结:
右旋 红父->黑父 黑祖->红祖

情况5:父节点为红色,叔叔节点为黑色,插入新节点为红色,插入新节点为父节点的右孩子节点。(黑叔左父右插入情况)

《红黑树插入节点》 7.png

解决办法:

这种使用上面的右旋会发现,就会出现两个值的节点和三个子节点的情况。我们先局部左旋父节点。然后将祖节点和叔节点右旋转。

总结:
左旋 右旋 黑祖->红祖 红新->黑新

情况6:父节点为红色,叔叔节点为红色,插入新节点为红色,插入新节点为父节点的左孩子节点。(红叔右父左插入情况)

《红黑树插入节点》 8.png

解决办法:

这种情况和情况2差不多,就是调整颜色就可以了,主要原因就可以发现父节点和叔叔节点都是红色,这样直接调整颜色,就会满足红黑树性质。

总结:
红父->黑父 红叔->黑叔 黑祖->红祖

情况7:父节点为红色,叔叔节点为红色,插入新节点为红色,插入新节点为父节点的右孩子节点。(红叔右父右插入情况)

《红黑树插入节点》 9.png

解决办法:

这种情况和情况3一样,都是只是调整下颜色就好。

总结:
红父->黑父 红叔->黑叔 黑祖->红祖

情况8:父节点为红色,叔叔节点为黑色,插入新节点为红色,插入新节点为父节点的右孩子节点。(黑叔右父右插入情况)

《红黑树插入节点》 10.png

解决办法:

这种情况会出现旋转了,因为叔节点和父节点颜色不同,所以单纯调整颜色不能满足性质了。就采用将祖节点和叔节点左旋,作为父节点的左孩子树。

总结:
左旋 红父->黑父 黑祖->红祖

情况9:父节点为红色,叔叔节点为黑色,插入新节点为红色,插入新节点为父节点的左孩子节点。(黑叔右父左插入情况)

《红黑树插入节点》 11.png

解决办法:

这种情况类似于情况5,如果我们直接左旋祖节点和叔节点,那么就会出现2节点,3孩子情况。所以为了避免这种冲突。就先进行局部旋转,先将父节点右旋,然后将祖节点和叔节点左旋。

总结:
右旋 左旋 黑祖->红祖 红新->黑新

全面总结

黑父,直接插入新节点即可。

红叔,就调整颜色即可。

黑叔,需要进行旋转操作。

红黑树插入元素完整代码实现

颜色枚举:

public enum Color {  
      
    RED("0","红色"),  
    BLACK("1","黑色");  
    private String name = ;  
    private String value =;  
    private Color(String name, String value) {  
        this.name=name;  
        this.value=value;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public String getValue() {  
        return value;  
    }  
    public void setValue(String value) {  
        this.value = value;  
    }  
    public static Color getEnumByName(String name){  
        if ( == name) {  
            return null;  
        }  
        for (Color type : values()) {  
            if (type.getName().equals(name.trim()))  
                return type;  
        }  
        return null;  
    }  
      
    public static Map<String, String> toMap() {  
        Map<String, String> enumDataMap = new LinkedHashMap<String, String>();  
        for (Color type : values()) {  
            enumDataMap.put(type.getName(), type.getValue());  
        }  
        return enumDataMap;  
    }  
      
}  

红黑树节点数据的结构定义:

public class RBNode {  
  
    private Integer data;  
    //红黑树中节点对应的颜色  
    private Color color;  
    //红黑树中当前节点的左孩子节点  
    private RBNode lchild;  
    //红黑树中当前节点的右孩子节点  
    private RBNode rchild;  
    //红黑树中当前节点的父节点  
    private RBNode parent;  
    public RBNode(){}  
    public RBNode(Integer data){  
        this.data =data;  
    }  
    public RBNode(Integer data,Color color,RBNode parent,RBNode lchild,RBNode rchild){  
        this.data =data;  
        this.color =color;  
        this.parent =parent;  
        this.lchild =lchild;  
        this.rchild =rchild;  
    }  
      
    public RBNode getParent() {  
        return parent;  
    }  
    public void setParent(RBNode parent) {  
        this.parent = parent;  
    }  
    public Integer getData() {  
        return data;  
    }  
    public void setData(Integer data) {  
        this.data = data;  
    }  
    public Color getColor() {  
        return color;  
    }  
    public void setColor(Color color) {  
        this.color = color;  
    }  
    public RBNode getLchild() {  
        return lchild;  
    }  
    public void setLchild(RBNode lchild) {  
        this.lchild = lchild;  
    }  
    public RBNode getRchild() {  
        return rchild;  
    }  
    public void setRchild(RBNode rchild) {  
        this.rchild = rchild;  
    }  
}  

主程序代码:

public class RBTree {    
      
    private static RBNode root =;    
        
    //顺时针右旋    
    public static void rotateByRight(RBNode rbn){    
        RBNode b =rbn.getLchild();    
        rbn.setLchild(b.getRchild());    
        if(b.getRchild() !=null){    
            b.getRchild().setParent(rbn);    
        }    
        b.setParent(rbn.getParent());    
        if(rbn.getParent() ==null){    
            root =;    
        }else{    
            if(rbn ==rbn.getParent().getRchild()){    
                rbn.getParent().setRchild(b);    
            }else{    
                rbn.getParent().setLchild(b);    
            }    
        }    
        b.setRchild(rbn);    
        rbn.setParent(b);    
    }    
        
    //逆时针左旋    
    public static void rotateByLeft(RBNode rbn){    
        RBNode d =rbn.getRchild();    
        rbn.setRchild(d.getLchild());    
        if(d.getLchild() !=null){    
            d.getLchild().setParent(rbn);    
        }    
        d.setParent(rbn.getParent());    
        if(rbn.getParent() ==null){    
            root =;    
        }else{    
            if(rbn ==rbn.getParent().getLchild()){    
                rbn.getParent().setLchild(d);    
            }else{    
                rbn.getParent().setRchild(d);    
            }    
        }    
        d.setLchild(rbn);    
        rbn.setParent(d);    
    }    
        
        
        
    //红黑树插入节点    
    private static void insertRBNode(RBNode insertNode){    
        RBNode tempRoot =root;    
        //给红黑树插入节点,先不考虑局部平衡问题    
        while(tempRoot !=null){    
            if(insertNode.getData()<tempRoot.getData()){    
                if(tempRoot.getLchild() !=null){    
                    tempRoot =tempRoot.getLchild();    
                }else{    
                    tempRoot.setLchild(insertNode);    
                    insertNode.setParent(tempRoot);    
                    break;    
                }    
            }else if(insertNode.getData()>tempRoot.getData()){    
                if(tempRoot.getRchild() !=null){    
                    tempRoot =tempRoot.getRchild();    
                }else{    
                    tempRoot.setRchild(insertNode);    
                    insertNode.setParent(tempRoot);    
                    break;    
                }    
            }    
        }    
        //插入节点设置为红色    
        insertNode.setColor(Color.RED);    
        insertNode.setLchild(null);    
        insertNode.setRchild(null);    
        adjustRBTree(insertNode);    
    }    
        
    //调整红黑树    
    public static void adjustRBTree(RBNode rbNode){    
        //定义父节点    
        RBNode parent =rbNode.getParent();    
        while(parent !=null && parent.getColor().equals(Color.RED)){    
            //定义祖父节点    
            RBNode grandParent =parent.getParent();    
            //如果父节点是祖父节点的左孩子    
            if(parent.equals(grandParent.getLchild())){    
                RBNode uncleNode =grandParent.getRchild();    
                //情况2、情况3:红叔    
                if(uncleNode !=null && uncleNode.getColor().equals(Color.RED)){    
                    uncleNode.setColor(Color.BLACK);    
                    parent.setColor(Color.BLACK);    
                    grandParent.setColor(Color.RED);    
                }else if(uncleNode !=null && uncleNode.getColor().equals(Color.BLACK) && parent.getLchild().equals(rbNode)){    
                    //情况4:黑叔,当前节点是左孩子    
                    rotateByRight(grandParent);    
                    parent.setColor(Color.BLACK);    
                    grandParent.setColor(Color.RED);    
                }else if(uncleNode !=null && uncleNode.getColor().equals(Color.BLACK) && parent.getRchild().equals(rbNode)){    
                    //情况5:黑叔,当前节点是右孩子    
                    rotateByLeft(parent);    
                    rotateByRight(grandParent);    
                    rbNode.setColor(Color.BLACK);    
                    grandParent.setColor(Color.RED);    
                }else{  
                    break;  
                }  
            }else{//如果父节点是祖父节点的右孩子    
                RBNode uncleNode =grandParent.getLchild();    
                //情况6、情况7:红叔    
                if(uncleNode !=null && uncleNode.getColor().equals(Color.RED)){    
                    uncleNode.setColor(Color.BLACK);    
                    parent.setColor(Color.BLACK);    
                    grandParent.setColor(Color.RED);    
                }else if(uncleNode !=null && uncleNode.getColor().equals(Color.BLACK) && parent.getRchild().equals(rbNode)){    
                    //情况8:黑叔,当前节点是右孩子    
                    rotateByLeft(grandParent);    
                    parent.setColor(Color.BLACK);    
                    grandParent.setColor(Color.RED);    
                }else if(uncleNode !=null && uncleNode.getColor().equals(Color.BLACK) && parent.getLchild().equals(rbNode)){    
                    //情况9:黑叔,当前节点是左孩子    
                    rotateByRight(parent);    
                    rotateByLeft(grandParent);    
                    grandParent.setColor(Color.RED);    
                    rbNode.setColor(Color.BLACK);    
                }else{  
                    break;  
                }  
            }    
        }    
        root.setColor(Color.BLACK);    
    }    
        
    public static void queryRBNodeByPre(RBNode root){    
        if(root !=null){    
            System.out.print(root.getData()+"["+root.getColor().getValue()+"]"+" - ");    
            queryRBNodeByPre(root.getLchild());    
            queryRBNodeByPre(root.getRchild());    
        }else{    
            return;    
        }    
    }    
        
    /*递归方式遍历红黑树    
     * root:为遍历红黑树的根节点    
     * 中序方式    
     * */    
    public static void queryRBNodeByOrder(RBNode root) {    
        if(root !=null ){    
            queryRBNodeByOrder(root.getLchild());    
            System.out.print(root.getData()+"["+root.getColor().getValue()+"]"+" - ");    
            queryRBNodeByOrder(root.getRchild());    
        }else{    
            return;    
        }    
    }    
   
    public static void main(String[] args) {    
        root =new RBNode(13,Color.BLACK,null,null,null);    
        insertRBNode(new RBNode(8));    
        insertRBNode(new RBNode(17));    
        insertRBNode(new RBNode(1));    
        insertRBNode(new RBNode(11));    
        insertRBNode(new RBNode(15));    
        insertRBNode(new RBNode(25));    
        insertRBNode(new RBNode(6));    
        insertRBNode(new RBNode(22));    
        insertRBNode(new RBNode(27));    
        /*initRBTree(new RBNode(6), root);    
        initRBTree(new RBNode(5), root);    
        initRBTree(new RBNode(4), root);    
        queryRBNodeByOrder(root);    
        System.out.println();    
        queryBSTNodeByPre(root);    
        System.out.println();    
        System.out.println("旋转值:");    
        //rotateByLeft(root.getLchild());    
        rotateByRight(root.getRchild());*/    
        queryRBNodeByPre(root);    
        System.out.println();    
        System.out.println("----------------");    
        queryRBNodeByOrder(root);   
          
        /*RBNode rbNode =getMinRchild(root);  
        System.out.println(rbNode.getData());*/  
    }    
}    

测试用例

《红黑树插入节点》 12.jpg

测试结果

《红黑树插入节点》 13.png

问题

在插入节点的时候,我直接使用root全局变量来操作的,发现程序的根节点被替换了,程序出现了问题。

后来才想到全局变量是在堆中开辟空间的,而堆是共享区域。方法体内定义的变量是在栈中开辟空间的,是在每个线程私有的区域,如果为了防止全局变量被修改,那么在方法中调用全局变量时,可以单独复制一份,以防止出现全局变量被修改。

如果读者发现博客中出现问题,谢谢评论指出。

参考

http://www.cnblogs.com/dongritengfei/archive/2010/06/16/1759209.html

http://www.cnblogs.com/skywang12345/p/3245399.html#commentform

https://www.ibm.com/developerworks/cn/java/j-lo-tree/index.html?ca=drs-

数据结构与算法分析(c语言)

    原文作者:sunpy
    原文地址: https://www.jianshu.com/p/350b003aa226
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞