历史上最负盛名的树，红黑树(是二分搜索树)
算法导论中的红黑树.png
计算机先驱.png
红黑树与2-3树的等价性
学习2-3树，不仅对于理解红黑树有帮助，对于理解B类树，也是大有帮助的！
2-3树的绝对平衡性
满足二分搜索树的基本性质
2-3树.png
2-3树是一颗绝对平衡的树.png
2-3树特性：
- 新添加节点永远不会讲节点添加到一个空的位置
2-3树绝对平衡的原理如下情况分析(4种情况)
-
- 插入2节点
2-节点.png
-
- 插入3节点
3-节点.png
-
- 插入3节点，父节点为2节点
3-节点父2-节点1.png
3-节点父2-节点2.png
-
- 插入3节点，父节点为3节点
3-节点父3-节点1.png
3-节点父3-节点2.png
$$$$$作业：实现一个2-3树！$$$$$$$$
红黑树与2-3树的等价性
红色的节点左倾斜是人为定义的
红色的节点左倾斜.png
红黑树与二三树1.png
红黑树与2-3树2.png
红黑树的基本性质和复杂性分析
由于红黑树和2-3树是等价的，所以能够很直观的确定红黑树的特点！
基本性质：
红节点一定属于一个黑节点的左孩子,2-3中对应的3节点对应红黑树中的黑节点和黑节点左下角的红节点
每个节点或者是红色的，或者是黑色的。
根节点是一定是黑色的,2-3树中，当根节点是二节点的时候明显对应为黑色，当跟节点是三节点的时候，红黑树中对应的红节点就跑到坐下角了。
每一个叶子节点(指最后的空节点，并不指左右节点都为空的那个节点)是黑色的相当于定义了空节点本身就是一个黑色的节点
-
如果一个节点是红色的，那么他的孩子节点都是黑色的2-3树中，红色节点对应的部分就是3节点，如果3节点的孩子是一个二节点，那当然没话说，是一个黑色节点，如果3节点的下面也是一个三节点，对应到红黑树中，就变成了一个黑节点以及黑节点左孩子红节点！
注意：这个结论对于黑节点不成立，黑节点的右孩子一定是黑色的，但是左孩子可能为黑，可能为红！
(核心)从任意一个节点到叶子结点，经过的黑色节点个数是一样的在2-3树中，保持着绝对的平衡性，说明这是一颗满二叉树，所有叶子节点的深度都是一样的，对应到红黑树中，也就对应着所有的黑节点。
红黑树是保持“黑平衡”的二叉树，严格意义上讲，不是平衡二叉树,最大高度为 2logn -- 高度的复杂度为O(logn)
复杂度.png
红黑树的查询操作比AVL树稍微要慢一些，但是添加和删除要优于AVL树
保持根节点为黑色和左旋转
红黑树添加新元素(红节点是参与融合的节点)
以 2-3树添加元素的过程来理解红黑树,如果添加进2-节点，形成一个3-节点,如果添加进3-及诶单，咱叔形成一个4-节点，再进行变形处理
在2-3树中，添加一个节点首先不能添加到一个空的位置，而是与已经有的节点进行融合，那么，对应到红黑树中添加一个新的节点永远的都是红色的节点！
2-3的融合过程永远对应的红节点
- 要保持最终的根节点为黑色，颜色翻转和左旋转
leftRotate
添加的节点为42红，翻转之后相当于添加的节点37红
颜色翻转和左旋转.png
- 向红黑树中的3节点添加元素
-
- 添加的节点在父节点的右子树上
flipColors
- 添加的节点在父节点的右子树上
添加的节点66红，然后进行颜色翻转，让父节点去融合
颜色翻转.png
-
- 添加的节点在父节点的左子树上 右旋转 ，父节点的颜色的保持原来父节点的颜色
右旋转1.png
翻转后，右子节点相当于新添加的红节点
右旋转2.png
颜色翻转2.png
添加元素情况总结
add添加元素所有的情况分析.png
红黑树代码的实现
import java.util.ArrayList;
import java.util.concurrent.BlockingDeque;
public class RBTree, V> {
private static final boolean RED = true;
private static final boolean BLACK = false;
private class Node{
public K key;
public V value;
public Node left, right;
public boolean color;
public Node(K key, V value){
this.key = key;
this.value = value;
this.left = null;
this.right = null;
this.color = RED;
}
}
private Node root;
private int size;
public RBTree(){
root = null;
size = 0;
}
public int getSize(){
return size;
}
public boolean isEmpty(){
return size == 0;
}
// 判断节点node的颜色
private boolean isRed(Node node){
if(node == null) // 当跟节点为空的时候，默认为黑节点
return BLACK;
return node.color;
}
/**左旋转
* node x
* / \ 左旋转 / \
* t1 x ---------> node t3
* / \ / \
* t2 t3 t1 t2
* */
private Node leftRotate(Node node) {
Node x = node.right;
Node t2 = x.right;
// 左旋转
x.left = node;
node.right = t2;
x.color = node.color; // x等于原来树的根节点
// 2-3树中，添加节点都是红节点，旋转交换之后，也必须
// 保证这个特性。所以要把node变为红色！(以2-3树举个例子：
// 一颗树先只有根节点为黑2，现在添加节点红4，对应到红黑树，
// 根节点就要变成黑4,左子树就要变成红2！)
node.color = RED;
return x;
}
/**右旋转
* node x
* / \ 右旋转 / \
* x t2 -------> y node
* / \ / \
* y t1 t1 t2
* */
private Node rightRotate(Node node) {
Node x = node.left;
// 右旋转
node.left = x.right;
x.right = node;
// 维护颜色
x.color = node.color;
node.color = RED;
return x;
}
// 颜色翻转，向3节点添加一个节点(节点对应的位置在右子树，
// 子节点变黑，父节点变红和上层进行融合)
private void flipColors(Node node) {
node.color = RED;
node.left.color = BLACK;
node.right.color = BLACK;
}
// 向红黑树中添加新的元素(key, value)
public void add(K key, V value){
root = add(root, key, value);
root.color = BLACK; // 保持最终的根节点为黑色
}
// 向以node为根的红黑树中插入元素(key, value)，递归算法
// 返回插入新节点后红黑树的根
private Node add(Node node, K key, V value){
if(node == null){
size ++;
return new Node(key, value);
}
if(key.compareTo(node.key) < 0)
node.left = add(node.left, key, value);
else if(key.compareTo(node.key) > 0)
node.right = add(node.right, key, value);
else // key.compareTo(node.key) == 0
node.value = value;
// 维护红黑树！！！！
// 左旋转(对应两种情况！)
if(isRed(node.right) && !isRed(node.left))
node = this.leftRotate(node.left);
// 右旋转
if(isRed(node.left) && isRed(node.left.left))
node = this.rightRotate(node.left);
// 颜色翻转
if(isRed(node.left) && isRed(node.right))
this.flipColors(node);
return node;
}
// 返回以node为根节点的二分搜索树中，key所在的节点
private Node getNode(Node node, K key){
if(node == null)
return null;
if(key.equals(node.key))
return node;
else if(key.compareTo(node.key) < 0)
return getNode(node.left, key);
else // if(key.compareTo(node.key) > 0)
return getNode(node.right, key);
}
public boolean contains(K key){
return getNode(root, key) != null;
}
public V get(K key){
Node node = getNode(root, key);
return node == null ? null : node.value;
}
public void set(K key, V newValue){
Node node = getNode(root, key);
if(node == null)
throw new IllegalArgumentException(key + " doesn't exist!");
node.value = newValue;
}
// 返回以node为根的二分搜索树的最小值所在的节点
private Node minimum(Node node){
if(node.left == null)
return node;
return minimum(node.left);
}
// 删除掉以node为根的二分搜索树中的最小节点
// 返回删除节点后新的二分搜索树的根
private Node removeMin(Node node){
if(node.left == null){
Node rightNode = node.right;
node.right = null;
size --;
return rightNode;
}
node.left = removeMin(node.left);
return node;
}
// 从二分搜索树中删除键为key的节点
public V remove(K key){
Node node = getNode(root, key);
if(node != null){
root = remove(root, key);
return node.value;
}
return null;
}
private Node remove(Node node, K key){
if( node == null )
return null;
if( key.compareTo(node.key) < 0 ){
node.left = remove(node.left , key);
return node;
}
else if(key.compareTo(node.key) > 0 ){
node.right = remove(node.right, key);
return node;
}
else{ // key.compareTo(node.key) == 0
// 待删除节点左子树为空的情况
if(node.left == null){
Node rightNode = node.right;
node.right = null;
size --;
return rightNode;
}
// 待删除节点右子树为空的情况
if(node.right == null){
Node leftNode = node.left;
node.left = null;
size --;
return leftNode;
}
// 待删除节点左右子树均不为空的情况
// 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
// 用这个节点顶替待删除节点的位置
Node successor = minimum(node.right);
successor.right = removeMin(node.right);
successor.left = node.left;
node.left = node.right = null;
return successor;
}
}
public static void main(String[] args){
System.out.println("Pride and Prejudice");
ArrayList words = new ArrayList<>();
if(FileOperation.readFile("pride-and-prejudice.txt", words)) {
System.out.println("Total words: " + words.size());
RBTree map = new RBTree<>();
for (String word : words) {
if (map.contains(word))
map.set(word, map.get(word) + 1);
else
map.add(word, 1);
}
System.out.println("Total different words: " + map.getSize());
System.out.println("Frequency of PRIDE: " + map.get("pride"));
System.out.println("Frequency of PREJUDICE: " + map.get("prejudice"));
}
System.out.println();
}
}
红黑树更多的相关内容
红黑树中删除节点：过程特别复杂！连红黑树的发明人Robert Sedgewick 在其经典著作《算法4》中都没有详细介绍具体的实现逻辑；以后有时间可以好好研究研究！
-
红黑树的倾斜
- 左倾红黑树：红节点在左子树，标准红黑树
- 右倾红黑树：红节点在右子树。
- 同时存在左倾和右倾：与2-4树等价，任何不平衡在三系旋转内解决
红黑树是一种统计性能优秀的树，另一种统计性优秀的树结构：Splay Tree(伸展树局部性原理：刚被访问的内容下次高概率被再次访问。)：
Java中的treeMap、treeSet这些有序的映射集合底层用的红黑树
红黑树的其他实现方式有很多，也有很多可以优化的地方,推荐看看《算法导论》中的红黑树的实现（添加和删除，用2-4树去理解！）
红黑树与其他树的性能总结：
对于完全随机的数据，普通的二分搜索树很好用！，缺点极端情况下回退化成链表（高度不平衡）
对于查询较多的使用情况，AVL树很好用
红黑树牺牲了平衡性（2logn大高度），统计性更优（综合增删改查所有的操作）