java实现红黑树

红黑树是一种经典的数据结构，在linux内存管理、nginx 等很多地方用到它。主要操作包括插入、删除，其中插入6种情况，删除8种情况，详细的思路就不说了，如果不太明白的请参考算法导论13章，看的时候一定要把每一种插入、删除的情况在纸上自己画出来，这样会节省你很多时间。下面是java实现的代码：

 package com.algorithm.rbtree;

 public class RBTree {

     private final Node NIL = new Node(null,null,null,Color.BLACK,-1);
     private Node root;

     public RBTree() {
         root = NIL;
     }

     public RBTree(Node  root) {
         this.root = root;
     }





     //插入节点
     public void rbInsert(Node node) {

         Node previous = NIL;
         Node temp = root;

         while (temp != NIL) {
             previous = temp;
             if (temp.getValue() < node.getValue()) {
                 temp = temp.getRight();
             } else {
                 temp = temp.getLeft();
             }
         }
         node.setParent(previous);

         if (previous == NIL) {
             root = node;
             root.setParent(NIL);
         } else  if (previous.getValue() > node.getValue()) {
             previous.setLeft(node);
         } else {
             previous.setRight(node);
         }

         node.setLeft(NIL);
         node.setRight(NIL);
         node.setColor(Color.RED);
         rb_Insert_Fixup(node);

     }

     //插入节点后的调整
     private void rb_Insert_Fixup(Node node) {

         while (node.getParent().getColor() == Color.RED) {

             if (node.getParent() == node.getParent().getParent().getLeft()) {

                 Node rightNuncle = node.getParent().getParent().getRight();

                 if (rightNuncle.getColor() == Color.RED) {         //Case 1

                     rightNuncle.setColor(Color.BLACK);
                     node.getParent().setColor(Color.BLACK);
                     node.getParent().getParent().setColor(Color.RED);
                     node = node.getParent().getParent();

                 } else if (node == node.getParent().getRight()) {  //case 2

                     node = node.getParent();
                     leftRotate(node);

                 } else {                                          //case 3

                     node.getParent().setColor(Color.BLACK);
                     node.getParent().getParent().setColor(Color.RED);

                     rightRotate(node.getParent().getParent());

                 }

             } else {

                 Node leftNuncle = node.getParent().getParent().getLeft();

                 if (leftNuncle.getColor() == Color.RED) {     //case 4

                     leftNuncle.setColor(Color.BLACK);
                     node.getParent().setColor(Color.BLACK);
                     node.getParent().getParent().setColor(Color.RED);
                     node = node.getParent().getParent();

                 } else if (node == node.getParent().getLeft()) { //case 5

                     node = node.getParent();
                     rightRotate(node);

                 } else {                                          // case 6

                     node.getParent().setColor(Color.BLACK);
                     node.getParent().getParent().setColor(Color.RED);
                     leftRotate(node.getParent().getParent());

                 }

             }


         }

         root.setColor(Color.BLACK);

     }


     //删除节点
     public Node rbDelete(int data) {

         Node node = search(data);
         Node temp = NIL;
         Node child = NIL;
         if (node == null) {
             return null;
         } else {
             if (node.getLeft() == NIL || node.getRight() == NIL) {
                 temp = node;
             } else {
                 temp = successor(node);
             }

             if (temp.getLeft() != NIL) {
                 child = temp.getLeft();
             } else {
                 child = temp.getRight();
             }

             child.setParent(temp.getParent());

             if (temp.getParent() == NIL) {
                 root = child;
             } else if (temp == temp.getParent().getLeft()) {
                 temp.getParent().setLeft(child);
             } else {
                 temp.getParent().setRight(child);
             }

             if (temp != node) {
                 node.setValue(temp.getValue());
             }

             if (temp.getColor() == Color.BLACK) {
                 rb_Delete_Fixup(child);
             }
             return temp;
         }




     }

     //删除节点后的调整
     private void rb_Delete_Fixup(Node node) {

         while (node != root && node.getColor() == Color.BLACK) {

             if (node == node.getParent().getLeft()) {

                 Node rightBrother = node.getParent().getRight();
                 if (rightBrother.getColor() == Color.RED) {          //case 1 node节点为左孩子，node节点的兄弟为RED
                     rightBrother.setColor(Color.BLACK);
                     node.getParent().setColor(Color.RED);
                     leftRotate(node.getParent());
                     rightBrother = node.getParent().getRight();
                 }

                 if (rightBrother.getLeft().getColor() == Color.BLACK && rightBrother.getRight().getColor() == Color.BLACK) {
                     rightBrother.setColor(Color.RED);
                     node = node.getParent();
                 } else if (rightBrother.getRight().getColor() == Color.BLACK) {
                     rightBrother.getLeft().setColor(Color.BLACK);
                     rightBrother.setColor(Color.RED);
                     rightRotate(rightBrother);
                     rightBrother = node.getParent().getRight();
                 } else {
                     rightBrother.setColor(node.getParent().getColor());
                     node.getParent().setColor(Color.BLACK);
                     rightBrother.getRight().setColor(Color.BLACK);
                     leftRotate(node.getParent());
                     node = root;
                 }


             } else {

                 Node leftBrother = node.getParent().getLeft();
                 if (leftBrother.getColor() == Color.RED) {
                     leftBrother.setColor(Color.BLACK);
                     node.getParent().setColor(Color.RED);
                     rightRotate(node.getParent());
                     leftBrother = node.getParent().getLeft();
                 }

                 if (leftBrother.getLeft().getColor() == Color.BLACK && leftBrother.getRight().getColor() == Color.BLACK) {
                     leftBrother.setColor(Color.RED);
                     node = node.getParent();

                 } else if (leftBrother.getLeft().getColor() == Color.BLACK) {

                     leftBrother.setColor(Color.RED);
                     leftBrother.getRight().setColor(Color.BLACK);
                     leftRotate(leftBrother);
                     leftBrother = node.getParent().getLeft();

                 } else {

                     leftBrother.setColor(node.getParent().getColor());
                     node.getParent().setColor(Color.BLACK);
                     leftBrother.getLeft().setColor(Color.BLACK);
                     rightRotate(node.getParent());
                     node = root;

                 }

             }

         }

         node.setColor(Color.BLACK);
     }


     //查找节点node的后继节点

     public Node successor(Node node) {

         Node rightChild = node.getRight();
         if  (rightChild != NIL) {
             Node previous = null;
             while (rightChild != NIL) {
                 previous = rightChild;
                 rightChild = rightChild.getLeft();
             }
             return previous;
         } else {

             Node parent = node.getParent();
             while (parent != NIL && node != parent.getLeft()) {
                 node = parent;
                 parent = parent.getParent();
             }

             return parent;

         }

     }


     //查找节点
     public Node search(int data) {
         Node temp = root;

         while (temp != NIL) {
             if (temp.getValue() == data) {
                 return temp;
             } else  if (data < temp.getValue()) {
                 temp = temp.getLeft();
             } else {
                 temp = temp.getRight();
             }
         }
         return null;
     }




     //左转函数
     private void leftRotate(Node node) {

         Node rightNode = node.getRight();

         node.setRight(rightNode.getLeft());
         if (rightNode.getLeft() != NIL) {
             rightNode.getLeft().setParent(node);
         }
         rightNode.setParent(node.getParent());

         if (node.getParent() == NIL) {
             rightNode = root;
         } else if (node == node.getParent().getLeft()) {
             node.getParent().setLeft(rightNode);
         } else {
             node.getParent().setRight(rightNode);
         }

         rightNode.setLeft(node);
         node.setParent(rightNode);


     }

     //右转函数
     private void rightRotate(Node node) {

         Node leftNode = node.getLeft();
         node.setLeft(leftNode.getRight());

         if (leftNode.getRight() != null) {
             leftNode.getRight().setParent(node);
         }

         leftNode.setParent(node.getParent());

         if (node.getParent() == NIL) {
             root = leftNode;
         } else if (node == node.getParent().getLeft()) {
             node.getParent().setLeft(leftNode);
         } else {
             node.getParent().setRight(leftNode);
         }

         leftNode.setRight(node);
         node.setParent(leftNode);

     }

     //中序遍历红黑树
     public void printTree() {
         inOrderTraverse(root);
     }

     private void inOrderTraverse(Node node) {

         if (node != NIL) {
             inOrderTraverse(node.getLeft());
             System.out.println(" 节点："+node.getValue() + "的颜色为：" + node.getColor());
             inOrderTraverse(node.getRight());
         }

     }


     public Node getNIL() {
         return NIL;
     }

 }



 class Node {
     private Node left;
     private Node right;
     private Node parent;
     private Color color;
     private int value;
     public Node(Node left, Node right, Node parent, Color color, int value) {
         super();
         this.left = left;
         this.right = right;
         this.parent = parent;
         this.color = color;
         this.value = value;
     }

     public Node() {
     }

     public Node(int value) {
         this(null,null,null,null,value);
     }

     public Node getLeft() {
         return left;
     }

     public void setLeft(Node left) {
         this.left = left;
     }

     public Node getRight() {
         return right;
     }

     public void setRight(Node right) {
         this.right = right;
     }

     public Node getParent() {
         return parent;
     }

     public void setParent(Node parent) {
         this.parent = parent;
     }

     public Color getColor() {
         return color;
     }

     public void setColor(Color color) {
         this.color = color;
     }

     public int getValue() {
         return value;
     }

     public void setValue(int value) {
         this.value = value;
     }

 }

 enum Color {
     RED,BLACK
 }

下面是测试代码：

 package com.algorithm.rbtree;

 public class RBTreeTest {

     /**
      * @param args
      */
     public static void main(String[] args) {

         RBTree rbTree = new RBTree();

         rbTree.rbInsert(new Node(41));
         rbTree.rbInsert(new Node(38));
         rbTree.rbInsert(new Node(31));
         rbTree.rbInsert(new Node(12));
         rbTree.rbInsert(new Node(19));
         rbTree.rbInsert(new Node(8));

         //rbTree.printTree();


         rbTree.rbDelete(19);

         rbTree.printTree();


     }

 }