红黑树的原理_红黑树的原理和TreeMap实现

红黑树是一种自平衡二叉查找树，它可以在O(logn)时间内做查找，插入和删除等操作，这使得它在实时应用中很有价值。可用来构造关联数组和集合，如Java中的TreeMap,TreeSet等。相对于AVL树来说，牺牲了部分平衡性以换取插入/删除操作时少量的旋转操作，整体来说性能要优于AVL树。
性质：
1、节点是红色或黑色。
2、根节点是黑色。
3、所有叶子都是黑色（叶子是NIL节点）。
4、每个红色节点必须有两个黑色的子节点。（从每个叶子到根的所有路径上不能有两个连续的红色节点。）
5、从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。
单个节点的构造如下：

static final class Entry<K,V> implements Map.Entry<K,V> {
        K key;
        V value;
        Entry<K,V> left;
        Entry<K,V> right;
        Entry<K,V> parent;
        boolean color = BLACK;
}

基本知识：

1.左旋：是将E的右子树S绕E逆时针旋转，使得E的右子树S成为E的父亲，同时修改相关节点的引用。旋转之后，二叉查找树的属性仍然满足。

private void rotateLeft(Entry<K,V> p) {
        if (p != null) {
            Entry<K,V> r = p.right;
            p.right = r.left;
            if (r.left != null)
                r.left.parent = p;
            r.parent = p.parent;
            if (p.parent == null)
                root = r;
            else if (p.parent.left == p)
                p.parent.left = r;
            else
                p.parent.right = r;
            r.left = p;
            p.parent = r;
        }
    }

2、右旋:右旋的过程是将S的左子树绕S顺时针旋转，使得S的左子树成为S的父亲，同时修改相关节点的引用。旋转之后，二叉查找树的属性仍然满足。

private void rotateRight(Entry<K,V> p) {
        if (p != null) {
            Entry<K,V> l = p.left;
            p.left = l.right;
            if (l.right != null) l.right.parent = p;
            l.parent = p.parent;
            if (p.parent == null)
                root = l;
            else if (p.parent.right == p)
                p.parent.right = l;
            else p.parent.left = l;
            l.right = p;
            p.parent = l;
        }
    }

3、后继节点:给定节点N，其后继节点是比N大 的最小的那个元素。如下图，如果节点（35）的右子树不为空，则其后继节点是右子树中最小的元素（45）；如果节点（30）的右子树为空，则其后继节点是其第一个为左节点的祖先的父亲。

static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
        if (t == null)
            return null;
        else if (t.right != null) {
            Entry<K,V> p = t.right;
            while (p.left != null)
                p = p.left;
            return p;
        } else {
            Entry<K,V> p = t.parent;
            Entry<K,V> ch = t;
            while (p != null && ch == p.right) {
                ch = p;
                p = p.parent;
            }
            return p;
        }
    }

查找：二叉树的查找，时间复杂度为O(logn)

final Entry<K,V> getEntry(Object key) {
        // Offload comparator-based version for sake of performance
        if (comparator != null)
            return getEntryUsingComparator(key);
        if (key == null)
            throw new NullPointerException();
            Comparable<? super K> k = (Comparable<? super K>) key;
        Entry<K,V> p = root;
        while (p != null) {
            int cmp = k.compareTo(p.key);
            if (cmp < 0)
                p = p.left;
            else if (cmp > 0)
                p = p.right;
            else
                return p;
        }
        return null;
    }

插入：首先先找出插入的位置，如果插入节点是黑色的，则违反了性质5，所以默认插入节点都是红色的，然后再通过调整颜色和左右旋使红黑树保持平衡。可分为以下几种情况:

1.被插入的节点是根节点。
处理方法：直接把此节点涂为黑色。
2.被插入的节点的父节点是黑色。
处理方法：什么也不需要做。节点被插入后，仍然是红黑树。
3.被插入的节点的父节点是红色。
处理方法：那么，该情况与红黑树的“特性(5)”相冲突。这种情况下，被插入节点是一定存在非空祖父节点的；进一步的讲，被插入节点也一定存在叔叔节点(即使叔叔节点为空，我们也视之为存在，空节点本身就是黑色节点)。理解这点之后，我们依据"叔叔节点的情况"，将这种情况进一步划分为3种情况(Case)。
假设要插入的结点为N，其父结点为P，其 祖父结点为G，其父亲的兄弟结点为U（即P和U 是同一个结点的两个子结点）。Case1:叔叔节点是红色节点
处理方法：
(01) 将“父节点”设为黑色。
(02) 将“叔叔节点”设为黑色。
(03) 将“祖父节点”设为“红色”。
(04) 将“祖父节点”设为“当前节点”(红色节点)；即，之后继续对“当前节点”进行操作。

Case2:叔叔是黑色，且当前节点是左孩子

处理方法：

(01) 将“父节点”设为“黑色”。

(02) 将“祖父节点”设为“红色”。

(03) 以“祖父节点”为支点进行右旋。

Case3:叔叔是黑色，且当前节点是右孩子

处理方法：

（01）以“父节点”为支点进行左旋

（02）以“父节点”作为“当前节点”，则变成了情况（2）

public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check

            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    //存在该key，则替换
                    return t.setValue(value);
            } while (t != null);
        }
//不存在，则插入
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }
    /**
     * 调整红黑树
     * @param Entry<K,V> x :待插入的节点
     */
private void fixAfterInsertion(Entry<K,V> x) {
//默认插入红色节点，否则违反性质5
        x.color = RED;

        while (x != null && x != root && x.parent.color == RED) {
//父亲节点为红色节点的时候需要调整
            if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
                Entry<K,V> y = rightOf(parentOf(parentOf(x)));
                if (colorOf(y) == RED) {                    //case1:叔叔节点为红色
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    x = parentOf(parentOf(x));
                } else {
                    if (x == rightOf(parentOf(x))) { //case3:叔叔节点为黑色，插入节点为右节点
                        x = parentOf(x);
                        rotateLeft(x);
                    }
//case2:叔叔节点为黑色，当前孩子是左孩子
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateRight(parentOf(parentOf(x)));
                }
            } else {  //镜像，父亲节点为祖父节点的右节点
                Entry<K,V> y = leftOf(parentOf(parentOf(x)));
                if (colorOf(y) == RED) {
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    x = parentOf(parentOf(x));
                } else {
                    if (x == leftOf(parentOf(x))) {
                        x = parentOf(x);
                        rotateRight(x);
                    }
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateLeft(parentOf(parentOf(x)));
                }
            }
        }
//重设根节点为黑色
        root.color = BLACK;
    }

删除：
步骤一：将红黑树当作一颗二叉查找树，将节点删除。
这和"删除常规二叉查找树中删除节点的方法是一样的"。分3种情况：
① 被删除节点没有儿子，即为叶节点。那么，直接将该节点删除就OK了。
② 被删除节点只有一个儿子。那么，直接删除该节点，并用该节点的唯一子节点顶替它的位置。
③ 被删除节点有两个儿子。那么，先找出它的后继节点；然后把“它的后继节点的内容”复制给“该节点的内容”；之后，删除“它的后继节点”。在这里，后继节点相当于替身，在将后继节点的内容复制给"被删除节点"之后，再将后继节点删除。这样就巧妙的将问题转换为"删除后继节点"的情况了，下面就考虑后继节点。 在"被删除节点"有两个非空子节点的情况下，它的后继节点不可能是双子非空。既然"的后继节点"不可能双子都非空，就意味着"该节点的后继节点"要么没有儿子，要么只有一个儿子。若没有儿子，则按"情况① "进行处理；若只有一个儿子，则按"情况② "进行处理。
步骤二：通过"旋转和重新着色"等一系列来修正该树，使之重新成为一棵红黑树。
因为"第一步"中删除节点之后，可能会违背红黑树的特性。所以需要通过"旋转和重新着色"来修正该树，使之重新成为一棵红黑树。
下面仅考虑情况① 和情况②红黑树的调整。
我们先用待删除结点的孩子代替待删除结点，并且记这个孩子为N(相当于在删除节点的位置用孩子节点或者叶子节点nil代替孩子节点)，记它的新的父结点为P，它的兄弟结点，也就是父结点的另外一个孩子为S， 记S的左孩子为SL,右孩子为SR。
（首先声明只有被删除节点是黑色节点的时候才需要调整，相当于删除之后所有原来经过该节点的子路径少了一个黑色节点，所以思路是要么其他所有路径也都少一个黑色节点，要么就在经过N节点的路径上都增加一个黑色节点。）Case1:N是新的根
相当于删除节点是根节点，则所有路径都少了一个黑色节点，直接将其子节点N（现在新的根节点）置为黑色就完了。Case2:P为红色，S和S的两个孩子都是黑色的
处理方法：将P置为黑色，S置为红色。
这样，不经过N的路径上的黑色结点数目并没有发生变化，而经过N结点的路径上黑色结点的数目 增加了1，刚好添补了这条路径上删除的黑色结点。所以红黑树又重新达到了平衡。

Case3:S是黑色，S的右儿子是红色，而N是它父亲的左儿子，P节点表示可为黑色也可以为红色
处理方法：绕父节点左旋，并交换P和S的颜色，将SR的颜色由红变黑。这样可以看到所有经过这段节点的路径（N，L，R）都还原为了未删除节点之前的两个黑色节点。

注：图片中的L节点为nil节点。Case4:S是黑色，S的左儿子是红色，S的右儿子是黑色，而N是它父亲的左儿子
处理方法：以S为节点右旋，然后交换SL和S的颜色，此时相当于回到了Case3:S是黑色，S的右儿子是红色，而N是它父亲的左儿子，P节点表示可为黑色也可以为红色，再重新调整即可。

Case5:S是红色,如果有子节点，则子节点一定为黑色

处理方法：以P节点左旋，然后交换P和S的颜色。此时回到了Case2:P为红色，兄弟节点L和它的两个孩子都是黑色的，然后再重新调整。

Case6:N的父亲、S和S的儿子都是黑色的。

处理方法：将S设置为黑色，则所有经过P的节点都少了一个黑色节点，然后以P为当前节点，从新开始调整红黑树。

public V remove(Object key) {
Entry<K,V> p = getEntry(key);
if (p == null)
return null;
V oldValue = p.value;
deleteEntry(p);
return oldValue;
}
/**
* Delete node p, and then rebalance the tree.
*/
private void deleteEntry(Entry<K,V> p) {
modCount++;
size--;
// If strictly internal, copy successor's element to p and then make p
// point to successor.
if (p.left != null && p.right != null) {
Entry<K,V> s = successor(p);
p.key = s.key;
p.value = s.value;
p = s;
} // 被删除节点有两个子节点 ，将后继节点的值拷贝到被删除节点，转化为被删除节点p为后继节点
// Start fixup at replacement node, if it exists.
Entry<K,V> replacement = (p.left != null ? p.left : p.right);
if (replacement != null) { //被删除节点有一个叶子节点的情况
// Link replacement to parent
replacement.parent = p.parent;
if (p.parent == null)
root = replacement; // N是新的根
else if (p == p.parent.left)
p.parent.left = replacement;
else
p.parent.right = replacement;
// Null out links so they are OK to use by fixAfterDeletion.
p.left = p.right = p.parent = null;
// Fix replacement
if (p.color == BLACK) //被删除节点是黑色才需要调整
fixAfterDeletion(replacement); //replacement就是被删除节点的替代节点
} else if (p.parent == null) { //被删除节点是根节点
root = null;
} else { // 被删除节点没有叶子节点，用被删除节点来当做nil节点进行调整
if (p.color == BLACK)
fixAfterDeletion(p);
if (p.parent != null) {
if (p == p.parent.left)
p.parent.left = null;
else if (p == p.parent.right)
p.parent.right = null;
p.parent = null;
}
}
}
/** Entry<K,V> x：被删除节点的替代节点
*/
private void fixAfterDeletion(Entry<K,V> x) {
while (x != root && colorOf(x) == BLACK) {
if (x == leftOf(parentOf(x))) {
Entry<K,V> sib = rightOf(parentOf(x)); //图示中的S节点
if (colorOf(sib) == RED) { //Case5:S是红色，转化为Case2
setColor(sib, BLACK);
setColor(parentOf(x), RED);
rotateLeft(parentOf(x));
sib = rightOf(parentOf(x));
}
if (colorOf(leftOf(sib)) == BLACK && //S和S的两个儿子都是黑色（如果P为黑色，则是Case6,否则将P设置为黑色就解决问题了）
colorOf(rightOf(sib)) == BLACK) {
setColor(sib, RED);//将S设置为红色
x = parentOf(x); //将P节点作为“当前替换节点”，重新考虑平衡问题
} else {
if (colorOf(rightOf(sib)) == BLACK) { //Case4:S的左儿子为红色，右儿子为黑色，N是它父亲的左儿子
setColor(leftOf(sib), BLACK);
setColor(sib, RED);
rotateRight(sib);
sib = rightOf(parentOf(x)); //转化为Case3
}
//Case3:S是黑色，S的右儿子是红色，N是他父亲的左儿子，P颜色未知
setColor(sib, colorOf(parentOf(x)));
setColor(parentOf(x), BLACK);
setColor(rightOf(sib), BLACK);
rotateLeft(parentOf(x));
x = root;
}
} else { // 镜像对称
Entry<K,V> sib = leftOf(parentOf(x));
if (colorOf(sib) == RED) {
setColor(sib, BLACK);
setColor(parentOf(x), RED);
rotateRight(parentOf(x));
sib = leftOf(parentOf(x));
}
if (colorOf(rightOf(sib)) == BLACK &&
colorOf(leftOf(sib)) == BLACK) {
setColor(sib, RED);
x = parentOf(x);
} else {
if (colorOf(leftOf(sib)) == BLACK) {
setColor(rightOf(sib), BLACK);
setColor(sib, RED);
rotateLeft(sib);
sib = leftOf(parentOf(x));
}
setColor(sib, colorOf(parentOf(x)));
setColor(parentOf(x), BLACK);
setColor(leftOf(sib), BLACK);
rotateRight(parentOf(x));
x = root;
}
}
}
//如果x是红色节点或根节点，则设置为黑色节点
setColor(x, BLACK);
}

二叉树遍历：

1.前序遍历：根节点->左子树->右子树
2.中序遍历：左子树->根节点->右子树
3.后序遍历：左子树->右子树->根节点

递归实现：

public class TreeNode {
int val;
TreeNode left;
TreeNode right;
public TreeNode(int x) {
val = x;
}
}
//前序遍历
public class Solution {
List<Integer> result = new ArrayList<Integer>();
public List<Integer> preorderTraversal(TreeNode root) {
dfs(root);
return result;
}
private void dfs(TreeNode root) {
if (root == null) {
return;
}
result.add(root.val);
dfs(root.left);
dfs(root.right);
}
}
//中序遍历
public class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
recurse(root, result);
return result;
}
private void recurse(TreeNode root, List<Integer> result) {
if (root == null) return;
recurse(root.left, result);
result.add(root.val);
recurse(root.right, result);
}
}
//后序遍历
public class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
recurse(root, result);
return result;
}
private void recurse(TreeNode root, List<Integer> result) {
if (root == null) return;
recurse(root.left, result);
recurse(root.right, result);
result.add(root.val);
}
}

原文地址：红黑树的原理和TreeMap实现
原文作者：Monica2333