本文共 5228 字，大约阅读时间需要 17 分钟。

参考资料:

二叉查找树    

二叉查找树，也称有序二叉树（ordered binary tree），或已排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树：

1. 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
2. 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
3. 任意节点的左、右子树也分别为二叉查找树。
4. 没有键值相等的节点（no duplicate nodes）。    

因为一棵由n个结点随机构造的二叉查找树的高度为lgn，所以顺理成章，二叉查找树的一般操作的执行时间为O(lgn)。但二叉查找树若退化成了一棵具有n个结点的线性链后，则这些操作最坏情况运行时间为O(n)。    

红黑树虽然本质上是一棵二叉查找树，但它在二叉查找树的基础上增加了着色和相关的性质使得红黑树相对平衡，从而保证了红黑树的查找、插入、删除的时间复杂度最坏为O(log n)。  

但它是如何保证一棵n个结点的红黑树的高度始终保持在logn的呢？

这就引出了红黑树的5个性质：

• 每个结点要么是红的要么是黑的。
• 根结点是黑的。  
• 每个叶结点（叶结点即指树尾端NIL指针或NULL结点）都是黑的。
•  如果一个结点是红的，那么它的两个儿子都是黑的。  
• 对于任意结点而言，其到叶结点树尾端NIL指针的每条路径都包含相同数目的黑结点。      

正是红黑树的这5条性质，红黑树的自平衡使得最长路径不会超过最短路径的两倍,使一棵n个结点的红黑树始终保持了logn的高度，从而也就解释了上面所说的“红黑树的查找、插入、删除的时间复杂度最坏为O(log n)”这一结论成立的原因。

为了符合这5个性质,当元素插入或删除时,红黑树用[变色]或旋转(左旋和右旋,左旋--逆时针方向,右旋--顺时针方向),下图就是以pivot-Y的链为轴进行左旋

（注：上述第3、5点性质中所说的NULL结点，包括wikipedia.算法导论上所认为的叶子结点即为树尾端的NIL指针，或者说NULL结点。然百度百科以及网上一些其它博文直接说的叶结点，则易引起误会，因，此叶结点非子结点）

定义节点:

public class RBTree
   
    > {    private RBTNode
    
      mRoot;    // 根结点    private static final boolean RED   = false;    private static final boolean BLACK = true;    public class RBTNode
     
      > {        boolean color;        // 颜色        T key;                // 关键字(键值)        RBTNode
      
        left;    // 左孩子        RBTNode
       
         right;    // 右孩子        RBTNode
        
          parent; // 父结点 public RBTNode(T key, boolean color, RBTNode
         
           parent, RBTNode
          
            left, RBTNode
           
             right) { this.key = key; this.color = color; this.parent = parent; this.left = left; this.right = right; } } ...}
           
          
         
        
       
      
     
    
   

左旋的java代码:

/*  * 对红黑树的节点(x)进行左旋转 * * 左旋示意图(对节点x进行左旋)： *      px                              px *     /                               / *    x                               y                 *   /  \      --(左旋)-.           / \                # *  lx   y                          x  ry      *     /   \                       /  \ *    ly   ry                     lx  ly   * * */private void leftRotate(RBTNode
   
     x) {    // 设置x的右孩子为y    RBTNode
    
      y = x.right;    // 将 “y的左孩子” 设为 “x的右孩子”；    // 如果y的左孩子非空，将 “x” 设为 “y的左孩子的父亲”    x.right = y.left;    if (y.left != null)        y.left.parent = x;    // 将 “x的父亲” 设为 “y的父亲”    y.parent = x.parent;    if (x.parent == null) {        this.mRoot = y;            // 如果 “x的父亲” 是空节点，则将y设为根节点    } else {        if (x.parent.left == x)            x.parent.left = y;    // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”        else            x.parent.right = y;    // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”    }        // 将 “x” 设为 “y的左孩子”    y.left = x;    // 将 “x的父节点” 设为 “y”    x.parent = y;}
    
   

添加操作:

/*  * 将结点插入到红黑树中 * * 参数说明： *     node 插入的结点        // 对应《算法导论》中的node */private void insert(RBTNode
   
     node) {    int cmp;    RBTNode
    
      y = null;    RBTNode
     
       x = this.mRoot;    // 1. 将红黑树当作一颗二叉查找树，将节点添加到二叉查找树中。    while (x != null) {        y = x;        cmp = node.key.compareTo(x.key);        if (cmp < 0)            x = x.left;        else            x = x.right;    }    node.parent = y;    if (y!=null) {        cmp = node.key.compareTo(y.key);        if (cmp < 0)            y.left = node;        else            y.right = node;    } else {        this.mRoot = node;    }    // 2. 设置节点的颜色为红色    node.color = RED;    // 3. 将它重新修正为一颗二叉查找树    insertFixUp(node);}/*  * 新建结点(key)，并将其插入到红黑树中 * * 参数说明： *     key 插入结点的键值 */public void insert(T key) {    RBTNode
      
        node=new RBTNode
       
        (key,BLACK,null,null,null);    // 如果新建结点失败，则返回。    if (node != null)        insert(node);}
       
      
     
    
   

添加后的修正操作:

/* * 红黑树插入修正函数 * * 在向红黑树中插入节点之后(失去平衡)，再调用该函数； * 目的是将它重新塑造成一颗红黑树。 * * 参数说明： *     node 插入的结点        // 对应《算法导论》中的z */private void insertFixUp(RBTNode
   
     node) {    RBTNode
    
      parent, gparent;    // 若“父节点存在，并且父节点的颜色是红色”    while (((parent = parentOf(node))!=null) && isRed(parent)) {        gparent = parentOf(parent);        //若“父节点”是“祖父节点的左孩子”        if (parent == gparent.left) {            // Case 1条件：叔叔节点是红色            RBTNode
     
       uncle = gparent.right;            if ((uncle!=null) && isRed(uncle)) {                setBlack(uncle);                setBlack(parent);                setRed(gparent);                node = gparent;                continue;            }            // Case 2条件：叔叔是黑色，且当前节点是右孩子            if (parent.right == node) {                RBTNode
      
        tmp;                leftRotate(parent);                tmp = parent;                parent = node;                node = tmp;            }            // Case 3条件：叔叔是黑色，且当前节点是左孩子。            setBlack(parent);            setRed(gparent);            rightRotate(gparent);        } else {    //若“z的父节点”是“z的祖父节点的右孩子”            // Case 1条件：叔叔节点是红色            RBTNode
       
         uncle = gparent.left;            if ((uncle!=null) && isRed(uncle)) {                setBlack(uncle);                setBlack(parent);                setRed(gparent);                node = gparent;                continue;            }            // Case 2条件：叔叔是黑色，且当前节点是左孩子            if (parent.left == node) {                RBTNode
        
          tmp; rightRotate(parent); tmp = parent; parent = node; node = tmp; } // Case 3条件：叔叔是黑色，且当前节点是右孩子。 setBlack(parent); setRed(gparent); leftRotate(gparent); } } // 将根节点设为黑色 setBlack(this.mRoot);}
        
       
      
     
    
   

转载地址：https://blog.csdn.net/liao0801_123/article/details/87909707 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！