数据结构——红黑树

红黑树也是一种平衡二叉查找树，经常用于替代AVL树，特点如下：

1. 根节点为黑色的，空节点也看做黑色节点；
2. 红色节点的子节点一定为黑色，任何一条路径不能出现两个连续的红节点；
3. 从任何一个节点出发，到空节点的路径上包含相同数目的黑节点，即如果忽略路径中的红色节点，红黑树是完全平衡的。

　　相对于AVL树，红黑树能够以O(log2 n) 的时间复杂度进行搜索、插入、删除操作。此外，由于它的设计，任何不平衡都会在三次旋转之内解决。当然，红黑树并不适应所有应用树的领域。如果数据基本上是静态的，那么让他们待在他们能够插入，并且不影响平衡的地方会具有更好的性能。如果数据完全是静态的，例如，做一个哈希表，性能可能会更好一些。
　　红黑树是一个更高效的检索二叉树，因此常常用来实现关联数组。典型地，JDK 提供的集合类 TreeMap 本身就是一个红黑树的实现。对于 TreeMap 而言，由于它底层采用一棵“红黑树”来保存集合中的 Entry，这意味这 TreeMap 添加元素、取出元素的性能都比 HashMap 低：当 TreeMap 添加元素时，需要通过循环找到新增 Entry 的插入位置，因此比较耗性能；当从 TreeMap 中取出元素时，需要通过循环才能找到合适的 Entry，也比较耗性能。但 TreeMap、TreeSet （TreeSet 底层是通过 TreeMap 来实现的）比 HashMap、HashSet 的优势在于：TreeMap 中的所有 Entry 总是按 key 根据指定排序规则保持有序状态，TreeSet 中所有元素总是根据指定排序规则保持有序状态。

用途：

AVL树:最早的平衡二叉树之一。应用相对其他数据结构比较少。windows对进程地址空间的管理用到了AVL树
红黑树:平衡二叉树，广泛用在C++的STL中。map和set都是用红黑树实现的。
B/B+树用在磁盘文件组织 数据索引和数据库索引

插入、删除思路：《算法导论》第13章

Java实现如下：

package com.tonyluis;

public class RBTree {
    
    //空节点
    private final Node NIL = new Node(null,null,null,Color.BLACK,-1);
    private Node root;
    
    public RBTree() {
        root = NIL;
    }
    
    public RBTree(Node  root) {
        this.root = root;
    }
    
    
    //插入节点
    public void rbInsert(Node node) {
        
        Node previous = NIL;
        Node temp = root;
        
        while (temp != NIL) {
            previous = temp;
            if (temp.getValue() < node.getValue()) {
                temp = temp.getRight();
            } else {
                temp = temp.getLeft();
            }
        }
        node.setParent(previous);
        
        if (previous == NIL) {
            root = node;
            root.setParent(NIL);
        } else  if (previous.getValue() > node.getValue()) {
            previous.setLeft(node);
        } else {
            previous.setRight(node);
        }
        
        node.setLeft(NIL);
        node.setRight(NIL);
        node.setColor(Color.RED);
        rb_Insert_Fixup(node);
        
    }
    
    //插入节点后的调整
    private void rb_Insert_Fixup(Node node) {
    
        while (node.getParent().getColor() == Color.RED) {
            
            if (node.getParent() == node.getParent().getParent().getLeft()) {
                
                Node rightNuncle = node.getParent().getParent().getRight();
                
                if (rightNuncle.getColor() == Color.RED) {         //Case 1
                    
                    rightNuncle.setColor(Color.BLACK);
                    node.getParent().setColor(Color.BLACK);
                    node.getParent().getParent().setColor(Color.RED);
                    node = node.getParent().getParent();
                                        
                } else if (node == node.getParent().getRight()) {  //case 2
                    
                    node = node.getParent();
                    leftRotate(node);
                    
                } else {                                          //case 3
                    
                    node.getParent().setColor(Color.BLACK);
                    node.getParent().getParent().setColor(Color.RED);
                    
                    rightRotate(node.getParent().getParent());
                    
                }
                                
            } else {
                
                Node leftNuncle = node.getParent().getParent().getLeft();
                
                if (leftNuncle.getColor() == Color.RED) {     //case 4
                    
                    leftNuncle.setColor(Color.BLACK);
                    node.getParent().setColor(Color.BLACK);
                    node.getParent().getParent().setColor(Color.RED);
                    node = node.getParent().getParent();
                
                } else if (node == node.getParent().getLeft()) { //case 5
                
                    node = node.getParent();
                    rightRotate(node);
                                        
                } else {                                          // case 6
                    
                    node.getParent().setColor(Color.BLACK);
                    node.getParent().getParent().setColor(Color.RED);
                    leftRotate(node.getParent().getParent());
                            
                }
                                
            }
            
            
        }
        
        root.setColor(Color.BLACK);
        
    }
    
    
    //删除节点
    public Node rbDelete(int data) {
        
        Node node = search(data);
        Node temp = NIL;
        Node child = NIL;
        if (node == null) {
            return null;
        } else {
            if (node.getLeft() == NIL || node.getRight() == NIL) {
                temp = node;            
            } else {
                temp = successor(node);
            }
            
            if (temp.getLeft() != NIL) {
                child = temp.getLeft();
            } else {
                child = temp.getRight();
            }
            
            child.setParent(temp.getParent());
            
            if (temp.getParent() == NIL) {
                root = child;
            } else if (temp == temp.getParent().getLeft()) {
                temp.getParent().setLeft(child);
            } else {
                temp.getParent().setRight(child);
            }
            
            if (temp != node) {
                node.setValue(temp.getValue());
            }
            
            if (temp.getColor() == Color.BLACK) {
                rb_Delete_Fixup(child);
            }
            return temp;
        }
        
        
        
        
    }
    
    //删除节点后的调整
    private void rb_Delete_Fixup(Node node) {
        
        while (node != root && node.getColor() == Color.BLACK) {
            
            if (node == node.getParent().getLeft()) {
                
                Node rightBrother = node.getParent().getRight();
                if (rightBrother.getColor() == Color.RED) {          //case 1 node节点为左孩子，node节点的兄弟为RED
                    rightBrother.setColor(Color.BLACK);
                    node.getParent().setColor(Color.RED);
                    leftRotate(node.getParent());
                    rightBrother = node.getParent().getRight();
                }
                
                if (rightBrother.getLeft().getColor() == Color.BLACK && rightBrother.getRight().getColor() == Color.BLACK) {
                    rightBrother.setColor(Color.RED);
                    node = node.getParent();
                } else if (rightBrother.getRight().getColor() == Color.BLACK) {
                    rightBrother.getLeft().setColor(Color.BLACK);
                    rightBrother.setColor(Color.RED);
                    rightRotate(rightBrother);
                    rightBrother = node.getParent().getRight();
                } else {
                    rightBrother.setColor(node.getParent().getColor());
                    node.getParent().setColor(Color.BLACK);
                    rightBrother.getRight().setColor(Color.BLACK);
                    leftRotate(node.getParent());
                    node = root;
                }
                
                
            } else {
                
                Node leftBrother = node.getParent().getLeft();
                if (leftBrother.getColor() == Color.RED) {
                    leftBrother.setColor(Color.BLACK);
                    node.getParent().setColor(Color.RED);
                    rightRotate(node.getParent());
                    leftBrother = node.getParent().getLeft();
                } 
                
                if (leftBrother.getLeft().getColor() == Color.BLACK && leftBrother.getRight().getColor() == Color.BLACK) {
                    leftBrother.setColor(Color.RED);
                    node = node.getParent();
                                                    
                } else if (leftBrother.getLeft().getColor() == Color.BLACK) {
                    
                    leftBrother.setColor(Color.RED);
                    leftBrother.getRight().setColor(Color.BLACK);
                    leftRotate(leftBrother);
                    leftBrother = node.getParent().getLeft();
                    
                } else {
                    
                    leftBrother.setColor(node.getParent().getColor());
                    node.getParent().setColor(Color.BLACK);
                    leftBrother.getLeft().setColor(Color.BLACK);
                    rightRotate(node.getParent());
                    node = root;
                                                            
                }
                                
            }
                    
        }
            
        node.setColor(Color.BLACK);
    }
    
    
    //查找节点node的后继节点

    public Node successor(Node node) {
        
        Node rightChild = node.getRight();
        if  (rightChild != NIL) {
            Node previous = null;
            while (rightChild != NIL) {
                previous = rightChild;
                rightChild = rightChild.getLeft();
            }
            return previous;
        } else {
            
            Node parent = node.getParent();
            while (parent != NIL && node != parent.getLeft()) {
                node = parent;
                parent = parent.getParent();
            }
            
            return parent;
                        
        }

    }
    
    
    //查找节点
    public Node search(int data) {
        Node temp = root;
        
        while (temp != NIL) {
            if (temp.getValue() == data) {
                return temp;
            } else  if (data < temp.getValue()) {
                temp = temp.getLeft();
            } else {
                temp = temp.getRight();
            }
        }
        return null;
    }
    
    
    
    
    //左转函数
    private void leftRotate(Node node) {
        
        Node rightNode = node.getRight();
        
        node.setRight(rightNode.getLeft());
        if (rightNode.getLeft() != NIL) {
            rightNode.getLeft().setParent(node);
        }
        rightNode.setParent(node.getParent());
        
        if (node.getParent() == NIL) {
            rightNode = root;
        } else if (node == node.getParent().getLeft()) {
            node.getParent().setLeft(rightNode);
        } else {
            node.getParent().setRight(rightNode);
        }
        
        rightNode.setLeft(node);
        node.setParent(rightNode);
        
        
    }
    
    //右转函数
    private void rightRotate(Node node) {
        
        Node leftNode = node.getLeft();
        node.setLeft(leftNode.getRight());
        
        if (leftNode.getRight() != null) {
            leftNode.getRight().setParent(node);
        }
        
        leftNode.setParent(node.getParent());
        
        if (node.getParent() == NIL) {
            root = leftNode;
        } else if (node == node.getParent().getLeft()) {
            node.getParent().setLeft(leftNode);
        } else {
            node.getParent().setRight(leftNode);
        }
        
        leftNode.setRight(node);
        node.setParent(leftNode);
                    
    }
    
    //中序遍历红黑树
    public void printTree() {
        inOrderTraverse(root);
    }
    
    private void inOrderTraverse(Node node) {
        
        if (node != NIL) {
            inOrderTraverse(node.getLeft());
            System.out.println(" 节点："+node.getValue() + "的颜色为：" + node.getColor());
            inOrderTraverse(node.getRight());
        }
        
    }
    
    
    public Node getNIL() {
        return NIL;
    }

}



class Node {
    private Node left;
    private Node right;
    private Node parent;
    private Color color;
    private int value;
    
    public Node() {
    }
    
    public Node(Node left, Node right, Node parent, Color color, int value) {
        super();
        this.left = left;
        this.right = right;
        this.parent = parent;
        this.color = color;
        this.value = value;
    }
    
    public Node(int value) {
        this(null,null,null,null,value);
    }

    public Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

    public Node getParent() {
        return parent;
    }

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

    public Color getColor() {
        return color;
    }

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

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }
    
}
enum Color {
    RED,BLACK
}

 红黑树的动态演示：

http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html