红黑树的java实现
经过几个星期的努力，红黑树终于弄清楚了。
先附上代码，然后贴上自己的分析图
package Alg;
public class RBTreeNode {
public enum Color {Red , Black };
private RBTreeNode leftChild = null;
private RBTreeNode rightChild = null;
private RBTreeNode parent = null;
private int value = Integer.MIN_VALUE;
private Color color = Color.Red;
private RBTreeNode(int val) {
this.setValue(val);
}
public static RBTreeNode createNode(int val) {
return new RBTreeNode(val);
}
public RBTreeNode getSibling() {
RBTreeNode p = this.parent;
if (p == null)
return null;
if (p.getLeftChild() == this)
return p.getRightChild();
return p.getLeftChild();
}
public boolean isRoot() {
if (this.parent == null)
return true;
return false;
}
public boolean isLeaf() {
if (this.getLeftChild() == null && this.getRightChild() == null)
return true;
return false;
}
public RBTreeNode getLeftChild() {
return leftChild;
}
public void setLeftChild(RBTreeNode leftChild) {
this.leftChild = leftChild;
}
public RBTreeNode getRightChild() {
return rightChild;
}
public void setRightChild(RBTreeNode rightChild) {
this.rightChild = rightChild;
}
public RBTreeNode getParent() {
return parent;
}
public void setParent(RBTreeNode parent) {
this.parent = parent;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Color getColor() {
return color;
}
public void setColor(Color color) {
this.color = color;
}
}
package Alg;
import Alg.RBTreeNode.Color;
public class RBTree {
public enum MatchType {E, GE, LE};
private RBTreeNode root = null;
private int count = 0;
public RBTreeNode search(int val, MatchType matchType) {
RBTreeNode n = search(val);
if (n == null)
return null;
if (n.getValue() == val)
return n;
switch (matchType) {
case LE:
if (n.getValue() < val)
return n;
return getLittleSmaller(n);
case GE:
if (n.getValue() > val)
return n;
return getLittleBigger(n);
default:
break;
}
return null;
}
public void insert(int val) throws Exception {
if (root == null) {
root = RBTreeNode.createNode(val);
count++;
root.setColor(RBTreeNode.Color.Black);
return;
}
RBTreeNode sNode = search(val);
if (sNode.getValue() == val)
return;
RBTreeNode x = RBTreeNode.createNode(val);
if (sNode.getValue() > val)
sNode.setLeftChild(x);
else
sNode.setRightChild(x);
x.setParent(sNode);
makeInsertedTreeBalance(x);
count++;
}
public void delete(int val) throws Exception {
if (root == null)
return ;
RBTreeNode x = search(val, MatchType.E);
if (x == null) //未找到删除节点
return ;
count--;
//如果待删除节点为根节点，则直接删除
if (count == 0) {
root = null;
return;
}
//以二叉树的节点删除方式，进行节点删除
RBTreeNode lc = x.getLeftChild(); //right child
RBTreeNode rc = x.getRightChild(); //left child
RBTreeNode rn = null; //被替换的节点replace node
if (lc != null && rc != null) {
//需要进行节点替换
RBTreeNode lrm = getRigthMostNode(lc);
RBTreeNode rlm = getLeftMostNode(rc);
switch (0) {
case 0:
// if (lrm.isLeaf() && lrm.getColor() == Color.Red){
// rn = lrm;
// break;
// }
// if (rlm.isLeaf() && lrm.getColor() == Color.Red) {
// rn = rlm;
// break;
// }
if (!lrm.isLeaf())
rn = lrm;
else
rn = rlm;
}
}
if (rn != null) {
int temp = x.getValue(); //为调试时观察方便
x.setValue(rn.getValue());
rn.setValue(temp);
x = rn;
}
if (x.getLeftChild() != null && x.getRightChild() != null)
throw new Exception("获取删除节点错误");
//x为待删除的节点
//简单情况1，待删除的节点为红色
RBTreeNode p = x.getParent();
if (x.getColor() == Color.Red) {
RBTreeNode nstr = null; //新子树的根节点。new sub tree root
if (x.getLeftChild() != null) {
nstr = x.getLeftChild();
}
else if (x.getRightChild() != null) {
nstr = x.getRightChild();
}
if (nstr != null)
nstr.setParent(p);
if (p == null) {
throw new Exception("红节点的父节点不可能为空");
}
if (p.getLeftChild() == x) {
p.setLeftChild(nstr);
}
else {
p.setRightChild(nstr);
}
return ;
}
//简单情况2，待删除节点子节点为黑色，其子节点为红色
if (x.getColor() == Color.Black) {
lc = x.getLeftChild();
rc = x.getRightChild();
if (lc != null && lc.getColor() == Color.Red) {
lc.setColor(Color.Black);
if (p == null) {
root = lc;
return;
}
if (p.getLeftChild() == x) {
p.setLeftChild(lc);
}
else {
p.setRightChild(lc);
}
lc.setParent(p);
return ;
}
if (rc != null && rc.getColor() == Color.Red) {
rc.setColor(Color.Black);
if (p == null) {
root = rc;
return;
}
if (p.getLeftChild() == x) {
p.setLeftChild(rc);
}
else {
p.setRightChild(rc);
}
rc.setParent(p);
return ;
}
}
//删除x节点，并进行重新平衡
RBTreeNode nstr = null; //new sub tree root
if (x.getLeftChild() != null)
nstr = x.getLeftChild();
else if (x.getRightChild() != null)
nstr = x.getRightChild();
p = x.getParent();
if (p == null) {
throw new Exception("此处为处理至多只有一个非空子树的删除情况，x为根节点而且有一个节点为黑色节点，这种情况不可能出现");
}
if (p.getLeftChild() == x)
p.setLeftChild(nstr);
else
p.setRightChild(nstr);
if (nstr != null)
nstr.setParent(p);
//重新平衡n和p
makeDeletedTreeBalance(nstr, p);
}
public RBTreeNode[] getAscOrderArray() {
if (root == null)
return null;
RBTreeNode[] ary = new RBTreeNode[count];
int pos = fillArrayInOrd(ary, 0, root);
if (pos != count)
return null;
return ary;
}
public void printInAscOrd() {
RBTreeNode[] ary = getAscOrderArray();
if (ary == null) {
System.out.println("空树");
return;
}
for (int i = 0; i < ary.length; i++)
System.out.print("[" + ary[i].getValue() + "]");
System.out.println();
}
//////////////////////辅助函数//////////////////////
private int fillArrayInOrd(RBTreeNode[] ary, int pos, RBTreeNode n) {
int npos = pos;
if (n.getLeftChild() != null)
npos = fillArrayInOrd(ary, pos, n.getLeftChild());
ary[npos] = n;
npos++;
if (n.getRightChild() != null)
npos = fillArrayInOrd(ary, npos, n.getRightChild());
return npos;
}
private RBTreeNode getSibling(RBTreeNode n) {
RBTreeNode p = n.getParent();
if (p != null) {
if (n == p.getLeftChild())
return p.getRightChild();
return p.getLeftChild();
}
return null;
}
private RBTreeNode rotateLeft(RBTreeNode n) {
RBTreeNode rc = n.getRightChild();
RBTreeNode subTree3 = rc.getLeftChild();
RBTreeNode p = n.getParent();
n.setRightChild(subTree3);
if (subTree3 != null) {
subTree3.setParent(n);
}
rc.setLeftChild(n);
n.setParent(rc);
rc.setParent(p);
if (p == null) {
root = rc;
return rc;
}
if (p.getLeftChild() == n) {
p.setLeftChild(rc);
}
else {
p.setRightChild(rc);
}
return rc;
}
private RBTreeNode rotateRight(RBTreeNode n) {
RBTreeNode lc = n.getLeftChild();
RBTreeNode subTree2 = lc.getRightChild();
RBTreeNode p = n.getParent();
n.setLeftChild(subTree2);
if (subTree2 != null)
subTree2.setParent(n);
lc.setRightChild(n);
n.setParent(lc);
lc.setParent(p);
if (p == null){
root = lc;
return lc;
}
if (p.getLeftChild() == n) {
p.setLeftChild(lc);
}
else {
p.setRightChild(lc);
}
return lc;
}
//////////////////////搜索函数//////////////////////
private RBTreeNode search(int val) {
if (root == null)
return null;
return search(root, val);
}
private RBTreeNode search(RBTreeNode n, int val) {
if (n.getValue() == val)
return n;
if (n.getValue() > val) {
if (n.getLeftChild() != null)
return search(n.getLeftChild(), val);
}
else {
if (n.getRightChild() != null)
return search(n.getRightChild(), val);
}
return n;
}
private RBTreeNode getLittleBigger(RBTreeNode n) {
if (n.getRightChild() != null)
return getLeftMostNode(n.getRightChild());
RBTreeNode p = n.getParent();
RBTreeNode s = n;
while (p != null) {
if (p.getLeftChild() == s)
break;
s = p;
p = p.getParent();
}
return p;
}
private RBTreeNode getLittleSmaller(RBTreeNode n) {
if (n.getLeftChild() != null)
return getRigthMostNode(n.getLeftChild());
RBTreeNode p = n.getParent();
RBTreeNode s = n;
while (p != null) {
if (p.getRightChild() == s)
break;
s = p;
p = p.getParent();
}
return p;
}
private RBTreeNode getLeftMostNode(RBTreeNode n) {
RBTreeNode l = n;
while (l.getLeftChild() != null) {
l = l.getLeftChild();
}
return l;
}
private RBTreeNode getRigthMostNode(RBTreeNode n) {
RBTreeNode r = n;
while (r.getRightChild() != null) {
r = r.getRightChild();
}
return r;
}
//////////////////////插入操作//////////////////////
private void makeInsertedTreeBalance(RBTreeNode x) throws Exception {
while (keepBalancing(x)) {
RBTreeNode p = x.getParent();
RBTreeNode pp = p.getParent();
BalanceCategory category = getBalanceCategory(x, p, pp);
switch (category) {
case CategoryA:
x = processCategoryA(x, p, pp);
break;
case CategoryB:
x = processCategoryB(x, p, pp);
break;
default:
throw new Exception("Unkonw category.fatal error");
}
}
if (x.isRoot())
root = x;
root.setColor(Color.Black);
}
private boolean keepBalancing(RBTreeNode x) {
if (x.isRoot() != true && x.getColor() == Color.Red) {
if (x.getParent().isRoot() == true)
return false;
if (x.getParent().getColor() == Color.Black)
return false;
return true;
}
return false;
}
private enum BalanceCategory {CategoryA, CategoryB};
private BalanceCategory getBalanceCategory(RBTreeNode x, RBTreeNode p, RBTreeNode pp) {
if (pp.getLeftChild() == p)
return BalanceCategory.CategoryA;
return BalanceCategory.CategoryB;
}
private RBTreeNode processCategoryA(RBTreeNode x, RBTreeNode p, RBTreeNode pp) {
BalanceCase balanceCase = getCategoryABalanceCase(x, p, pp);
if (balanceCase == BalanceCase.Case1) {
//处理父节点的兄弟节点为红节点的情况
return processCategoryACase1(x, p, pp);
}
else {
if (balanceCase == BalanceCase.Case2) {
//处理当前节点为右子节点的情况
return processCategoryACase2(x, p, pp);
}
//case2处理后得到的结果就是case3，此处进行case3的处理
return processCategoryACase3(x, p, pp);
}
}
private RBTreeNode processCategoryB(RBTreeNode x, RBTreeNode p, RBTreeNode pp) {
BalanceCase balanceCase = getCategoryBBalanceCase(x, p, pp);
if (balanceCase == BalanceCase.Case1) {
//处理父节点的兄弟节点为红节点的情况
return processCategoryBCase1(x, p, pp);
}
else {
if (balanceCase == BalanceCase.Case2) {
//处理当前节点为右子节点的情况
return processCategoryBCase2(x, p, pp);
}
//case2处理后得到的结果就是case3，此处进行case3的处理
return processCategoryBCase3(x, p, pp);
}
}
private enum BalanceCase { Case1, Case2, Case3 };
private BalanceCase getCategoryABalanceCase(RBTreeNode x, RBTreeNode p, RBTreeNode pp) {
RBTreeNode ancle = pp.getRightChild();
if (ancle != null && ancle.getColor() == Color.Red)
return BalanceCase.Case1;
else if (p.getRightChild() == x)
return BalanceCase.Case2;
return BalanceCase.Case3;
}
private BalanceCase getCategoryBBalanceCase(RBTreeNode x, RBTreeNode p, RBTreeNode pp) {
RBTreeNode ancle = pp.getLeftChild();
if (ancle != null && pp.getLeftChild().getColor() == Color.Red)
return BalanceCase.Case1;
else if (p.getLeftChild() == x)
return BalanceCase.Case2;
return BalanceCase.Case3;
}
private RBTreeNode processCategoryACase1(RBTreeNode x, RBTreeNode p, RBTreeNode pp) {
RBTreeNode ancle = pp.getRightChild();
pp.setColor(Color.Red);
p.setColor(Color.Black);
ancle.setColor(Color.Black);
return pp;
}
private RBTreeNode processCategoryACase2(RBTreeNode x, RBTreeNode p, RBTreeNode pp) {
RBTreeNode temp = x.getLeftChild();
p.setRightChild(temp);
if (temp != null)
temp.setParent(p);
x.setLeftChild(p);
p.setParent(x);
pp.setLeftChild(x);
x.setParent(pp);
return p;
}
private RBTreeNode processCategoryACase3(RBTreeNode x, RBTreeNode p, RBTreeNode pp) {
RBTreeNode temp = p.getRightChild();
RBTreeNode ppp = pp.getParent();
boolean isRight = false;
if (ppp != null) {
if (ppp.getRightChild() == pp)
isRight = true;
}
pp.setLeftChild(temp);
if (temp != null)
temp.setParent(pp);
pp.setColor(Color.Red);
p.setRightChild(pp);
p.setParent(pp.getParent());
pp.setParent(p);
p.setColor(Color.Black);
if (ppp != null){
if (isRight)
ppp.setRightChild(p);
else
ppp.setLeftChild(p);
}
return p;
}
private RBTreeNode processCategoryBCase1(RBTreeNode x, RBTreeNode p, RBTreeNode pp) {
RBTreeNode ancle = pp.getLeftChild();
pp.setColor(Color.Red);
p.setColor(Color.Black);
ancle.setColor(Color.Black);
return pp;
}
private RBTreeNode processCategoryBCase2(RBTreeNode x, RBTreeNode p, RBTreeNode pp) {
RBTreeNode temp = x.getRightChild();
p.setLeftChild(temp);
if (temp != null)
temp.setParent(p);
x.setRightChild(p);
p.setParent(x);
pp.setRightChild(x);
x.setParent(pp);
return p;
}
private RBTreeNode processCategoryBCase3(RBTreeNode x, RBTreeNode p, RBTreeNode pp) {
RBTreeNode temp = p.getLeftChild();
RBTreeNode ppp = pp.getParent();
boolean isRight = false;
if (ppp != null) {
if (ppp.getRightChild() == pp)
isRight = true;
}
pp.setRightChild(p.getLeftChild());
if (temp != null)
temp.setParent(pp);
pp.setColor(Color.Red);
p.setLeftChild(pp);
p.setParent(pp.getParent());
pp.setParent(p);
p.setColor(Color.Black);
if (ppp != null){
if (isRight)
ppp.setRightChild(p);
else
ppp.setLeftChild(p);
}
return p;
}
/////////////////////删除函数/////////////////////
//由维基的红黑树删除算法中描述的6种情况
private enum DeleteBalanceCase {case1, case2l, case2r, case3, case4, case5l, case5r, case6l, case6r};
private DeleteBalanceCase getDeleteCase(RBTreeNode n, RBTreeNode p, RBTreeNode s) throws Exception {
if (p == null) //平衡至根节点
return DeleteBalanceCase.case1;
if (s == null)
throw new Exception("树结构出现错误");
if (s.getColor() == Color.Red) {
if (n == p.getLeftChild())
return DeleteBalanceCase.case2l;
return DeleteBalanceCase.case2r;
}
else {
boolean slcIsBlack = false;
boolean srcIsBlack = false;
if (s.getLeftChild() == null || s.getLeftChild().getColor() == Color.Black)
slcIsBlack = true;
if (s.getRightChild() == null || s.getRightChild().getColor() == Color.Black)
srcIsBlack = true;
if (slcIsBlack == true && srcIsBlack == true) {
if (p.getColor() == Color.Black) {
return DeleteBalanceCase.case3;
}
else {
return DeleteBalanceCase.case4;
}
}
if (n == p.getLeftChild()) {
if (srcIsBlack) //slcIsBlack must be false
return DeleteBalanceCase.case5l;
return DeleteBalanceCase.case6l;
}
else {
if (slcIsBlack) //srcIsBlack must be false
return DeleteBalanceCase.case5r;
return DeleteBalanceCase.case6r;
}
}
}
private void makeDeletedTreeBalance(RBTreeNode n, RBTreeNode p) throws Exception {
RBTreeNode s = null; //sibling
if (p.getLeftChild() == n)
s = p.getRightChild();
else
s = p.getLeftChild();
while (true) {
DeleteBalanceCase c = getDeleteCase(n, p, s);
switch (c) {
case case1:
//达到根节点
return;
case case2l:
//左旋，在原有节点继续平衡
p.setColor(Color.Red);
s.setColor(Color.Black);
rotateLeft(p);
s = p.getRightChild();
break;
case case2r:
//右旋，在原节点继续平衡
p.setColor(Color.Red);
s.setColor(Color.Black);
rotateRight(p);
s = p.getLeftChild();
break;
case case3:
s.setColor(Color.Red);
n = p;
p = n.getParent();
s = getSibling(n);
break;
case case4:
p.setColor(Color.Black);
s.setColor(Color.Red);
return;
case case5l:
s.setColor(Color.Red);
s.getLeftChild().setColor(Color.Black);
s = rotateRight(s);
break;
case case5r:
s.setColor(Color.Red);
s.getRightChild().setColor(Color.Black);
s = rotateLeft(s);
break;
case case6l:
s.setColor(p.getColor());
p.setColor(Color.Black);
s.getRightChild().setColor(Color.Black);
rotateLeft(p);
return;
case case6r:
s.setColor(p.getColor());
p.setColor(Color.Black);
s.getLeftChild().setColor(Color.Black);
rotateRight(p);
return;
}
//
}
}
/////////////////////测试用例/////////////////////
private static int[] tree1Ary = {53, 12, 27, 99, 46, 5, 38};
private static RBTree buildTree1() {
RBTree tree = new RBTree();
try {
for (int i = 0; i < tree1Ary.length; i++) {
tree.insert(tree1Ary[i]);
}
return tree;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static void testInsertCase1() {
RBTree tree = buildTree1();
if (tree == null)
System.out.println("构造树出现错误");
tree.printInAscOrd();
}
private static int[] tree2Ary = {524, 3, 12, 198, 137, 652, 911, 1, 0, 999};
private static RBTree buildTree2() {
RBTree tree = new RBTree();
try {
for (int i = 0; i < tree2Ary.length; i++) {
tree.insert(tree2Ary[i]);
}
return tree;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static void testInsertCase2() {
RBTree tree = buildTree2();
if (tree == null)
System.out.println("构造树出现错误");
tree.printInAscOrd();
}
private static int[] tree3Ary = {111, 222, 333, 444, 555, 666, 777, 888, 999, 456};
public static RBTree buildTree3() {
RBTree tree = new RBTree();
try {
for (int i = 0; i < tree3Ary.length; i++) {
tree.insert(tree3Ary[i]);
}
return tree;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static void testInsertCase3() {
RBTree tree = buildTree3();
if (tree == null)
System.out.println("构造树出现错误");
tree.printInAscOrd();
}
private static int[] tree4Ary = {471, 192, 4, 798, 3, 1, 500, 250, 521, 650, 999, 72, 108, 25, 14};
public static RBTree buildTree4() {
RBTree tree = new RBTree();
try {
for (int i = 0; i < tree4Ary.length; i++) {
tree.insert(tree4Ary[i]);
}
return tree;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static void testInsertCase4() {
RBTree tree = buildTree4();
if (tree == null)
System.out.println("构造树出现错误");
tree.printInAscOrd();
}
private static int[] tree5Ary = {64, 88, 100, 67, 788, 675, 234, 1, 444, 209, 578, 23, 777, 345, 904, 755, 289, 666, 498, 629, 103, 402, 388, 922, 518, 101, 823, 65};
public static RBTree buildTree5() {
RBTree tree = new RBTree();
try {
for (int i = 0; i < tree5Ary.length; i++) {
tree.insert(tree5Ary[i]);
}
return tree;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static void testInsertCase5() {
RBTree tree = buildTree5();
if (tree == null)
System.out.println("构造树出现错误");
tree.printInAscOrd();
}
public static void testDeleteCase1() {
RBTree tree = new RBTree();
try {
tree.insert(50);
tree.insert(15);
tree.insert(100);
tree.printInAscOrd();
tree.delete(15);
tree.printInAscOrd();
tree.delete(100);
tree.printInAscOrd();
tree.delete(50);
tree.printInAscOrd();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void testDeleteCase2() {
RBTree tree = buildTree1();
if (tree == null) {
System.out.println("构造树错误");
return;
}
tree.printInAscOrd();
for (int i = 0; i < tree1Ary.length; i++) {
try {
System.out.println("删除"+tree1Ary[i]);
tree.delete(tree1Ary[i]);
tree.printInAscOrd();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void testDeleteCate2() {
RBTree tree = buildTree2();
if (tree == null) {
System.out.println("构造树错误");
return;
}
tree.printInAscOrd();
for (int i = 0; i < tree2Ary.length; i++) {
try {
System.out.println("删除"+tree2Ary[i]);
tree.delete(tree2Ary[i]);
tree.printInAscOrd();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void testDeleteCate3() {
RBTree tree = buildTree3();
if (tree == null) {
System.out.println("构造树错误");
return;
}
tree.printInAscOrd();
for (int i = 0; i < tree3Ary.length; i++) {
try {
System.out.println("删除"+tree3Ary[i]);
tree.delete(tree3Ary[i]);
tree.printInAscOrd();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void testDeleteCate4() {
RBTree tree = buildTree4();
if (tree == null) {
System.out.println("构造树错误");
return;
}
tree.printInAscOrd();
for (int i = 0; i < tree4Ary.length; i++) {
try {
System.out.println("删除"+tree4Ary[i]);
tree.delete(tree4Ary[i]);
tree.printInAscOrd();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void testDeleteCate5() {
RBTree tree = buildTree4();
if (tree == null) {
System.out.println("构造树错误");
return;
}
tree.printInAscOrd();
for (int i = 0; i < tree4Ary.length; i++) {
try {
System.out.println("删除"+tree4Ary[i]);
tree.delete(tree4Ary[i]);
tree.printInAscOrd();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}