红黑棋Java_红黑树的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();

}

}

}

}