2-3树
性质:
满足二分搜索树基本性质;
节点可以存放一个元素或者两个元素;
是一棵绝对平衡的树;
二节点 三节点
对2-3树来说,添加节点一定不会添加到空的位置
① ② ③
④ ⑤
红黑树
红黑树是保持“黑平衡”的二叉树,严格来说不是平衡二叉树
左旋转
① ②
③ ④
右旋转
① ②
③ ④
⑤
代码实现:
public class RBTree<K extends Comparable<K>, V> implements Map<K, 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;
left = null;
right = null;
color = RED;
}
}
//根节点
private Node root;
private int size;
public RBTree() {
root = null;
size = 0;
}
//判断节点node的颜色
private boolean isRed(Node node) {
if (null == node) {
return BLACK;
}
return node.color;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public int getSize() {
return size;
}
//向红黑树添加元素(key, value)
@Override
public void add(K key, V value) {
root = add(root, key, value);
root.color = BLACK;
}
//左旋转
private Node leftRotate(Node node){
Node x = node.right;
node.right = x.left;
x.left = node;
x.color = node.color;
node.color = RED;
return x;
}
//右旋转
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;
}
//颜色翻转
private void flipColors(Node node){
node.color = RED;
node.left.color= BLACK;
node.right.color= BLACK;
}
//返回插入新节点后红黑树的根
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 {
node.value = value;
}
//颜色翻转
if(isRed(node.right) && !isRed(node.left)){
Node leftRotate = leftRotate(node);
}
if(isRed(node.left) && isRed(node.left.left)){
Node rightRotate = rightRotate(node);
}
if(isRed(node.right) && isRed(node.left)){
flipColors(node);
}
return node;
}
private Node getNode(Node node, K key) {
if (null == node) {
return null;
}
if (key.compareTo(node.key) < 0) {
return getNode(node.left, key);
}
if (key.compareTo(node.key) > 0) {
return getNode(node.right, key);
}
if (key.compareTo(node.key) == 0) {
return node;
}
return null;
}
@Override
public V get(K key) {
Node node = getNode(root, key);
return node == null ? null : node.value;
}
@Override
public boolean contains(K key) {
return null != getNode(root, key);
}
@Override
public void set(K key, V newValue) {
Node node = getNode(root, key);
if (null == node) {
throw new IllegalArgumentException(key + "this key is empty!");
}
node.value = newValue;
}
@Override
public V remove(K key) {
Node node = getNode(root, key);
if (null != node) {
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.right = remove(node.right, key);
return node;
} else if (key.compareTo(node.key) < 0) {
node.left = remove(node.left, key);
return node;
} else {
//待删除元素左子树为空
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 succer = minNum(node.right);
succer.right = romveMin(node.right);
succer.left = node.left;
node.left = node.right = null;
return succer;
}
}
private Node minNum(Node node) {
if (node.left == null) {
return node;
}
return minNum(node.left);
}
private Node romveMin(Node node) {
if (node.left == null) {
Node rightNode = node.right;
node.right = null;
size--;
return rightNode;
}
node.left = romveMin(node.left);
return node;
}
}