红黑树初版
package acmcode;
/**
* Red-Black Tree
*
* @author Leon.Chen
*/
public class RBTree {
/**
* 红
*/
private static final String RED = "red";
/**
* 黑
*/
private static final String BLACK = "black";
/**
* 根节点
*/
private RBNode root;
/**
* 左旋转
*
* @param x
*/
private void leftRotate(RBNode x) {
RBNode y = x.right;
x.right = y.left;
y.left.parent = x;
y.parent = x.parent;
if (x.parent == null) {
root = y;
} else {
if (x == x.parent.left) {
x.parent.left = y;
} else {
x.parent.right = y;
}
}
y.left = x;
x.parent = y;
}
/**
* 右旋转
*
* @param y
*/
private void rightRotate(RBNode y) {
RBNode x = y.left;
y.left = x.right;
x.right.parent = y;
x.parent = y.parent;
if (y.parent == null) {
root = x;
} else {
if (y == y.parent.left) {
y.parent.left = x;
} else {
y.parent.right = x;
}
}
x.right = y;
y.parent = x;
}
/**
* 红黑树插入方法
*
* @param z
*/
public void RBInsert(RBNode z) {
if (root == null) {
root = z;
root.color = BLACK;
} else {
RBNode x = root;
RBNode y = null;
while (isNotNilNode(x)) {
y = x;
if (z.value.compareTo(x.value) < 0) {
x = x.left;
} else {
x = x.right;
}
}
if (z.value.compareTo(y.value) < 0) {
y.left = z;
} else {
y.right = z;
}
z.color = RED;
z.parent = y;
}
z.left = new RBNode(BLACK);
z.right = new RBNode(BLACK);
RBInsertFixUp(z);
}
/**
* 解决插入冲突
*
* @param z
*/
private void RBInsertFixUp(RBNode z) {
while (z.parent != null && z.parent.color.equals(RED)) {
if (z.parent == z.parent.parent.left) {
RBNode y = z.parent.parent.right;
if (y.color.equals(RED)) {
z.parent.color = BLACK;
y.color = BLACK;
z.parent.parent.color = RED;
z = z.parent.parent;
} else if (z == z.parent.right) {
z = z.parent;
leftRotate(z);
} else if (z == z.parent.left) {
z.parent.color = BLACK;
z.parent.parent.color = RED;
rightRotate(z.parent.parent);
}
} else {
RBNode y = z.parent.parent.left;
if (y.color.equals(RED)) {
z.parent.color = BLACK;
y.color = BLACK;
z.parent.parent.color = RED;
z = z.parent.parent;
} else if (z == z.parent.left) {
z = z.parent;
rightRotate(z);
} else if (z == z.parent.right) {
z.parent.color = BLACK;
z.parent.parent.color = RED;
leftRotate(z.parent.parent);
}
}
}
root.color = BLACK;
}
/**
* @param deleteNode
*/
public void RBDelete(RBNode deleteNode) {
RBNode y = null;
RBNode z = serach(deleteNode.value);
if (isNilNode(z.left) || isNilNode(z.right)) {
y = z;
} else {
y = treeSuccessor(z);
}
RBNode x = null;
if (isNotNilNode(y.left)) {
x = y.left;
} else {
x = y.right;
}
x.parent = y.parent;
if (isNilNode(y.parent)) {
root = x;
} else {
if (y == y.parent.left) {
y.parent.left = x;
} else {
y.parent.right = x;
}
}
if (y != z) {
z.value = y.value;
}
if (y.color.equals(BLACK)) {
RBDeleteFixUp(x);
}
}
/**
* @param x
*/
private void RBDeleteFixUp(RBNode x) {
System.out.println("===="+x.value);
// 解决黑黑冲突,完善中
while (x != root && x.color.equals(BLACK)) {
if (x == x.parent.left) {
RBNode w = x.parent.right;
if (w.color.equals(RED)) {
w.color = BLACK;
x.parent.color = RED;
leftRotate(x.parent);
w = x.parent.right;
} else if (w.left.color.equals(BLACK) && w.right.color.equals(BLACK)) {
w.color = RED;
x = x.parent;
} else if (w.right.color.equals(BLACK)) {
w.left.color = BLACK;
w.color = RED;
rightRotate(w);
w = x.parent.right;
} else if (w.left.color.equals(BLACK)) {
w.color = x.parent.color;
x.parent.color = BLACK;
w.right.color = BLACK;
leftRotate(x.parent);
x = root;
}
} else {
RBNode w = x.parent.left;
if (w.color.equals(RED)) {
w.color = BLACK;
x.parent.color = RED;
rightRotate(x.parent);
w = x.parent.left;
} else if (w.left.color.equals(BLACK) && w.right.color.equals(BLACK)) {
w.color = RED;
x = x.parent;
} else if (w.left.color.equals(BLACK)) {
w.right.color = BLACK;
w.color = RED;
leftRotate(w);
w = x.parent.left;
} else if (w.right.color.equals(BLACK)) {
w.color = x.parent.color;
x.parent.color = BLACK;
w.left.color = BLACK;
rightRotate(x.parent);
x = root;
}
}
}
x.color = BLACK;
}
/**
* 找后继
*
* @param node
* @return RBNode
*/
public RBNode treeSuccessor(RBNode node) {
if (node.right != null) {
return treeMiniMum(node.right);
}
RBNode currentNode = getParentNode(node);
while (currentNode != null && node == currentNode.right) {
node = currentNode;
currentNode = getParentNode(node);
}
return currentNode;
}
/**
* 找前驱
*
* @param node
* @return RBNode
*/
public RBNode treePrecursor(RBNode node) {
if (node.left != null) {
return treeMaxiMum(node.left);
}
RBNode currentNode = getParentNode(node);
while (currentNode != null && node == currentNode.left) {
node = currentNode;
currentNode = getParentNode(node);
}
return currentNode;
}
/**
* 最大节点
*
* @param node
* @return RBNode
*/
public RBNode treeMaxiMum(RBNode node) {
while (isNotNilNode(node.right)) {
node = node.right;
}
return node;
}
/**
* 最小节点
*
* @param node
* @return RBNode
*/
public RBNode treeMiniMum(RBNode node) {
while (isNotNilNode(node.left)) {
node = node.left;
}
return node;
}
/**
* 找节点的父节点
*
* @param node
* @return TreeNode
*/
public RBNode getParentNode(RBNode node) {
RBNode current = root;
RBNode trailCurrent = null;
while (isNotNilNode(current)) {
if (current.value.compareTo(node.value) == 0) {
break;
}
trailCurrent = current;
if (node.value.compareTo(current.value) < 0) {
current = current.left;
} else {
current = current.right;
}
}
return trailCurrent;
}
/**
* 搜索
*
* @param value
* @return TreeNode
*/
public RBNode serach(RBValue value) {
return treeSerach(root, value);
}
/**
* 搜索
*
* @param node
* @param value
* @return TreeNode
*/
public RBNode treeSerach(RBNode node, RBValue value) {
if (isNotNilNode(node) && node.value.compareTo(value) == 0) {
return node;
}
if (value.compareTo(node.value) < 0) {
return treeSerach(node.left, value);
} else {
return treeSerach(node.right, value);
}
}
/**
* 中序遍历
*
* @param node
*/
public void inOrder(RBNode node) {
if (isNotNilNode(node)) {
inOrder(node.left);
System.out.println(node.value+","+node.color);
inOrder(node.right);
}
}
/**
* 先序遍历
*
* @param node
*/
public void perOrder(RBNode node) {
if (isNotNilNode(node)) {
System.out.println(node.value+","+node.color);
perOrder(node.left);
perOrder(node.right);
}
}
/**
* @param node
* @return 是否为NIL[T]节点
*/
private boolean isNotNilNode(RBNode node) {
return node != null && node.value != null;
}
/**
* @param node
* @return 是否为NIL[T]节点
*/
private boolean isNilNode(RBNode node) {
return !isNotNilNode(node);
}
/**
* @param args
*/
public static void main(String[] args) {
RBTree tree = new RBTree();
tree.RBInsert(new RBNode(new RBValue(3)));
tree.RBInsert(new RBNode(new RBValue(4)));
tree.RBInsert(new RBNode(new RBValue(12)));
tree.RBInsert(new RBNode(new RBValue(13)));
tree.RBInsert(new RBNode(new RBValue(11)));
tree.RBInsert(new RBNode(new RBValue(15)));
tree.RBDelete(new RBNode(new RBValue(12)));
System.out.println("=================");
System.out.println("root = "+tree.root.value);
System.out.println("=================");
tree.inOrder(tree.root);
System.out.println("=================");
tree.perOrder(tree.root);
}
}
package acmcode;
/**
* @author Leon.Chen
*
*/
public class RBNode {
public RBNode parent;
public RBNode left;
public RBNode right;
public RBValue value;
public String color;
public RBNode(String color) {
this.color = color;
}
public RBNode() {
}
public RBNode(RBValue value) {
this.value = value;
}
}
package acmcode;
public class RBValue {
public int value;
public RBValue(int value) {
this.value = value;
}
public int compareTo(RBValue otherValue) {
int thisVal = this.value;
int anotherVal = otherValue.value;
return (thisVal < anotherVal ? -1 : (thisVal == anotherVal ? 0 : 1));
}
public String toString() {
return new Integer(value).toString();
}
}
忘了附图