原文鏈接：https://blog.csdn.net/xiaokang123456kao/article/details/54379724
作者：美團點評技術團隊
鏈接：https://zhuanlan.zhihu.com/p/24367771
來源：知乎
著作權歸作者所有。商業轉載請聯繫作者獲得授權，非商業轉載請註明出處。
紅黑樹是平衡二叉查找樹的一種。爲了深入理解紅黑樹，我們需要從二叉查找樹開始講起。
BST
二叉查找樹（Binary Search Tree，簡稱BST）是一棵二叉樹，它的左子節點的值比父節點的值要小，右節點的值要比父節點的值大。它的高度決定了它的查找效率。
在理想的情況下，二叉查找樹增刪查改的時間複雜度爲O(logN)（其中N爲節點數），最壞的情況下爲O(N)。當它的高度爲logN+1時，我們就說二叉查找樹是平衡的。
BST的查找操作
T key = a search key
Node root = point to the root of a BST
while(true){
if(root==null){
break;
}
if(root.value.equals(key)){
return root;
}
else if(key.compareTo(root.value)<0){
root = root.left;
}
else{
root = root.right;
}
}
return null;
從程序中可以看出，當BST查找的時候，先與當前節點進行比較：
- 如果相等的話就返回當前節點；
- 如果少於當前節點則繼續查找當前節點的左節點；
- 如果大於當前節點則繼續查找當前節點的右節點。
直到當前節點指針爲空或者查找到對應的節點，程序查找結束。
BST的插入操作
Node node = create a new node with specify value
Node root = point the root node of a BST
Node parent = null;
//find the parent node to append the new node
while(true){
if(root==null)break;
parent = root;
if(node.value.compareTo(root.value)<=0){
root = root.left;
}else{
root = root.right;
}
}
if(parent!=null){
if(node.value.compareTo(parent.value)<=0){//append to left
parent.left = node;
}else{//append to right
parent.right = node;
}
}
插入操作先通過循環查找到待插入的節點的父節點，和查找父節點的邏輯一樣，都是比大小，小的往左，大的往右。找到父節點後，對比父節點，小的就插入到父節點的左節點，大就插入到父節點的右節點上。
BST的刪除操作
刪除操作的步驟如下：
- 查找到要刪除的節點。
- 如果待刪除的節點是葉子節點，則直接刪除。
- 如果待刪除的節點不是葉子節點，則先找到待刪除節點的中序遍歷的後繼節點，用該後繼節點的值替換待刪除的節點的值，然後刪除後繼節點。
BST存在的問題
BST存在的主要問題是，數在插入的時候會導致樹傾斜，不同的插入順序會導致樹的高度不一樣，而樹的高度直接的影響了樹的查找效率。理想的高度是logN，最壞的情況是所有的節點都在一條斜線上，這樣的樹的高度爲N。
RBTree
基於BST存在的問題，一種新的樹——平衡二叉查找樹(Balanced BST)產生了。平衡樹在插入和刪除的時候，會通過旋轉操作將高度保持在logN。其中兩款具有代表性的平衡樹分別爲AVL樹和紅黑樹。AVL樹由於實現比較複雜，而且插入和刪除性能差，在實際環境下的應用不如紅黑樹。
紅黑樹（Red-Black Tree，以下簡稱RBTree）的實際應用非常廣泛，比如Linux內核中的完全公平調度器、高精度計時器、ext3文件系統等等，各種語言的函數庫如Java的TreeMap和TreeSet，C++ STL的map、multimap、multiset等。
RBTree也是函數式語言中最常用的持久數據結構之一，在計算幾何中也有重要作用。值得一提的是，Java 8中HashMap的實現也因爲用RBTree取代鏈表，性能有所提升。
RBTree的定義
RBTree的定義如下:
- 任何一個節點都有顏色，黑色或者紅色
- 根節點是黑色的
- 父子節點之間不能出現兩個連續的紅節點
- 任何一個節點向下遍歷到其子孫的葉子節點，所經過的黑節點個數必須相等
- 空節點被認爲是黑色的
數據結構表示如下：
class Node<T>{
public T value;
public Node<T> parent;
public boolean isRed;
public Node<T> left;
public Node<T> right;
}
RBTree在理論上還是一棵BST樹，但是它在對BST的插入和刪除操作時會維持樹的平衡，即保證樹的高度在[logN,logN+1]（理論上，極端的情況下可以出現RBTree的高度達到2*logN，但實際上很難遇到）。這樣RBTree的查找時間複雜度始終保持在O(logN)從而接近於理想的BST。RBTree的刪除和插入操作的時間複雜度也是O(logN)。RBTree的查找操作就是BST的查找操作。
RBTree的旋轉操作
旋轉操作(Rotate)的目的是使節點顏色符合定義，讓RBTree的高度達到平衡。
Rotate分爲left-rotate（左旋）和right-rotate（右旋），區分左旋和右旋的方法是：待旋轉的節點從左邊上升到父節點就是右旋，待旋轉的節點從右邊上升到父節點就是左旋。
RBTree的查找操作
RBTree的查找操作和BST的查找操作是一樣的。請參考BST的查找操作代碼。
RBTree的插入操作
RBTree的插入與BST的插入方式是一致的，只不過是在插入過後，可能會導致樹的不平衡，這時就需要對樹進行旋轉操作和顏色修復（在這裏簡稱插入修復），使得它符合RBTree的定義。
新插入的節點是紅色的，插入修復操作如果遇到父節點的顏色爲黑則修復操作結束。也就是說，只有在父節點爲紅色節點的時候是需要插入修復操作的。
插入修復操作分爲以下的三種情況，而且新插入的節點的父節點都是紅色的：
- 叔叔節點也爲紅色。
- 叔叔節點爲空，且祖父節點、父節點和新節點處於一條斜線上。
- 叔叔節點爲空，且祖父節點、父節點和新節點不處於一條斜線上。
插入操作-case 1
case 1的操作是將父節點和叔叔節點與祖父節點的顏色互換，這樣就符合了RBTRee的定義。即維持了高度的平衡，修復後顏色也符合RBTree定義的第三條和第四條。下圖中，操作完成後A節點變成了新的節點。如果A節點的父節點不是黑色的話，則繼續做修復操作。
插入操作-case 2
case 2的操作是將B節點進行右旋操作，並且和父節點A互換顏色。通過該修復操作RBTRee的高度和顏色都符合紅黑樹的定義。如果B和C節點都是右節點的話，只要將操作變成左旋就可以了。
插入操作-case 3
case 3的操作是將C節點進行左旋，這樣就從case 3轉換成case 2了，然後針對case 2進行操作處理就行了。case 2操作做了一個右旋操作和顏色互換來達到目的。如果樹的結構是下圖的鏡像結構，則只需要將對應的左旋變成右旋，右旋變成左旋即可。
插入操作的總結
插入後的修復操作是一個向root節點回溯的操作，一旦牽涉的節點都符合了紅黑樹的定義，修復操作結束。之所以會向上回溯是由於case 1操作會將父節點，叔叔節點和祖父節點進行換顏色，有可能會導致祖父節點不平衡(紅黑樹定義3)。這個時候需要對祖父節點爲起點進行調節（向上回溯）。
祖父節點調節後如果還是遇到它的祖父顏色問題，操作就會繼續向上回溯，直到root節點爲止，根據定義root節點永遠是黑色的。在向上的追溯的過程中，針對插入的3中情況進行調節。直到符合紅黑樹的定義爲止。直到牽涉的節點都符合了紅黑樹的定義，修復操作結束。
如果上面的3中情況如果對應的操作是在右子樹上，做對應的鏡像操作就是了。
RBTree的刪除操作
刪除操作首先需要做的也是BST的刪除操作，刪除操作會刪除對應的節點，如果是葉子節點就直接刪除，如果是非葉子節點，會用對應的中序遍歷的後繼節點來頂替要刪除節點的位置。刪除後就需要做刪除修復操作，使的樹符合紅黑樹的定義，符合定義的紅黑樹高度是平衡的。
刪除修復操作在遇到被刪除的節點是紅色節點或者到達root節點時，修復操作完畢。
刪除修復操作是針對刪除黑色節點纔有的，當黑色節點被刪除後會讓整個樹不符合RBTree的定義的第四條。需要做的處理是從兄弟節點上借調黑色的節點過來，如果兄弟節點沒有黑節點可以借調的話，就只能往上追溯，將每一級的黑節點數減去一個，使得整棵樹符合紅黑樹的定義。
刪除操作的總體思想是從兄弟節點借調黑色節點使樹保持局部的平衡，如果局部的平衡達到了，就看整體的樹是否是平衡的，如果不平衡就接着向上追溯調整。
刪除修復操作分爲四種情況(刪除黑節點後)：
- 待刪除的節點的兄弟節點是紅色的節點。
- 待刪除的節點的兄弟節點是黑色的節點，且兄弟節點的子節點都是黑色的。
- 待調整的節點的兄弟節點是黑色的節點，且兄弟節點的左子節點是紅色的，右節點是黑色的(兄弟節點在右邊)，如果兄弟節點在左邊的話，就是兄弟節點的右子節點是紅色的，左節點是黑色的。
- 待調整的節點的兄弟節點是黑色的節點，且右子節點是是紅色的(兄弟節點在右邊)，如果兄弟節點在左邊，則就是對應的就是左節點是紅色的。
刪除操作-case 1
由於兄弟節點是紅色節點的時候，無法借調黑節點，所以需要將兄弟節點提升到父節點，由於兄弟節點是紅色的，根據RBTree的定義，兄弟節點的子節點是黑色的，就可以從它的子節點借調了。
case 1這樣轉換之後就會變成後面的case 2，case 3，或者case 4進行處理了。上升操作需要對C做一個左旋操作，如果是鏡像結構的樹只需要做對應的右旋操作即可。
之所以要做case 1操作是因爲兄弟節點是紅色的，無法借到一個黑節點來填補刪除的黑節點。
刪除操作-case 2
case 2的刪除操作是由於兄弟節點可以消除一個黑色節點，因爲兄弟節點和兄弟節點的子節點都是黑色的，所以可以將兄弟節點變紅，這樣就可以保證樹的局部的顏色符合定義了。這個時候需要將父節點A變成新的節點，繼續向上調整，直到整顆樹的顏色符合RBTree的定義爲止。
case 2這種情況下之所以要將兄弟節點變紅，是因爲如果把兄弟節點借調過來，會導致兄弟的結構不符合RBTree的定義，這樣的情況下只能是將兄弟節點也變成紅色來達到顏色的平衡。當將兄弟節點也變紅之後，達到了局部的平衡了，但是對於祖父節點來說是不符合定義4的。這樣就需要回溯到父節點，接着進行修復操作。
刪除操作-case 3
case 3的刪除操作是一箇中間步驟，它的目的是將左邊的紅色節點借調過來，這樣就可以轉換成case 4狀態了，在case 4狀態下可以將D，E節點都階段過來，通過將兩個節點變成黑色來保證紅黑樹的整體平衡。
之所以說case-3是一箇中間狀態，是因爲根據紅黑樹的定義來說，下圖並不是平衡的，他是通過case 2操作完後向上回溯出現的狀態。之所以會出現case 3和後面的case 4的情況，是因爲可以通過借用侄子節點的紅色，變成黑色來符合紅黑樹定義4.
刪除操作-case 4
Case 4的操作是真正的節點借調操作，通過將兄弟節點以及兄弟節點的右節點借調過來，並將兄弟節點的右子節點變成紅色來達到借調兩個黑節點的目的，這樣的話，整棵樹還是符合RBTree的定義的。
Case 4這種情況的發生只有在待刪除的節點的兄弟節點爲黑，且子節點不全部爲黑，纔有可能借調到兩個節點來做黑節點使用，從而保持整棵樹都符合紅黑樹的定義。
刪除操作的總結
紅黑樹的刪除操作是最複雜的操作，複雜的地方就在於當刪除了黑色節點的時候，如何從兄弟節點去借調節點，以保證樹的顏色符合定義。由於紅色的兄弟節點是沒法借調出黑節點的，這樣只能通過選擇操作讓他上升到父節點，而由於它是紅節點，所以它的子節點就是黑的，可以借調。
對於兄弟節點是黑色節點的可以分成3種情況來處理，當所以的兄弟節點的子節點都是黑色節點時，可以直接將兄弟節點變紅，這樣局部的紅黑樹顏色是符合定義的。但是整顆樹不一定是符合紅黑樹定義的，需要往上追溯繼續調整。
對於兄弟節點的子節點爲左紅右黑或者 (全部爲紅，右紅左黑)這兩種情況，可以先將前面的情況通過選擇轉換爲後一種情況，在後一種情況下，因爲兄弟節點爲黑，兄弟節點的右節點爲紅，可以借調出兩個節點出來做黑節點，這樣就可以保證刪除了黑節點，整棵樹還是符合紅黑樹的定義的，因爲黑色節點的個數沒有改變。
紅黑樹的刪除操作是遇到刪除的節點爲紅色，或者追溯調整到了root節點，這時刪除的修復操作完畢。
RBTree的Java實現
public class RBTreeNode<T extends Comparable<T>> {
private T value;//node value
private RBTreeNode<T> left;//left child pointer
private RBTreeNode<T> right;//right child pointer
private RBTreeNode<T> parent;//parent pointer
private boolean red;//color is red or not red
public RBTreeNode(){}
public RBTreeNode(T value){this.value=value;}
public RBTreeNode(T value,boolean isRed){this.value=value;this.red = isRed;}
public T getValue() {
return value;
}
void setValue(T value) {
this.value = value;
}
RBTreeNode<T> getLeft() {
return left;
}
void setLeft(RBTreeNode<T> left) {
this.left = left;
}
RBTreeNode<T> getRight() {
return right;
}
void setRight(RBTreeNode<T> right) {
this.right = right;
}
RBTreeNode<T> getParent() {
return parent;
}
void setParent(RBTreeNode<T> parent) {
this.parent = parent;
}
boolean isRed() {
return red;
}
boolean isBlack(){
return !red;
}
/**
* is leaf node
**/
boolean isLeaf(){
return left==null && right==null;
}
void setRed(boolean red) {
this.red = red;
}
void makeRed(){
red=true;
}
void makeBlack(){
red=false;
}
@Override
public String toString(){
return value.toString();
}
}
public class RBTree<T extends Comparable<T>> {
private final RBTreeNode<T> root;
//node number
private java.util.concurrent.atomic.AtomicLong size =
new java.util.concurrent.atomic.AtomicLong(0);
//in overwrite mode,all node's value can not has same value
//in non-overwrite mode,node can have same value, suggest don't use non-overwrite mode.
private volatile boolean overrideMode=true;
public RBTree(){
this.root = new RBTreeNode<T>();
}
public RBTree(boolean overrideMode){
this();
this.overrideMode=overrideMode;
}
public boolean isOverrideMode() {
return overrideMode;
}
public void setOverrideMode(boolean overrideMode) {
this.overrideMode = overrideMode;
}
/**
* number of tree number
* @return
*/
public long getSize() {
return size.get();
}
/**
* get the root node
* @return
*/
private RBTreeNode<T> getRoot(){
return root.getLeft();
}
/**
* add value to a new node,if this value exist in this tree,
* if value exist,it will return the exist value.otherwise return null
* if override mode is true,if value exist in the tree,
* it will override the old value in the tree
*
* @param value
* @return
*/
public T addNode(T value){
RBTreeNode<T> t = new RBTreeNode<T>(value);
return addNode(t);
}
/**
* find the value by give value(include key,key used for search,
* other field is not used,@see compare method).if this value not exist return null
* @param value
* @return
*/
public T find(T value){
RBTreeNode<T> dataRoot = getRoot();
while(dataRoot!=null){
int cmp = dataRoot.getValue().compareTo(value);
if(cmp<0){
dataRoot = dataRoot.getRight();
}else if(cmp>0){
dataRoot = dataRoot.getLeft();
}else{
return dataRoot.getValue();
}
}
return null;
}
/**
* remove the node by give value,if this value not exists in tree return null
* @param value include search key
* @return the value contain in the removed node
*/
public T remove(T value){
RBTreeNode<T> dataRoot = getRoot();
RBTreeNode<T> parent = root;
while(dataRoot!=null){
int cmp = dataRoot.getValue().compareTo(value);
if(cmp<0){
parent = dataRoot;
dataRoot = dataRoot.getRight();
}else if(cmp>0){
parent = dataRoot;
dataRoot = dataRoot.getLeft();
}else{
if(dataRoot.getRight()!=null){
RBTreeNode<T> min = removeMin(dataRoot.getRight());
//x used for fix color balance
RBTreeNode<T> x = min.getRight()==null ? min.getParent() : min.getRight();
boolean isParent = min.getRight()==null;
min.setLeft(dataRoot.getLeft());
setParent(dataRoot.getLeft(),min);
if(parent.getLeft()==dataRoot){
parent.setLeft(min);
}else{
parent.setRight(min);
}
setParent(min,parent);
boolean curMinIsBlack = min.isBlack();
//inherit dataRoot's color
min.setRed(dataRoot.isRed());
if(min!=dataRoot.getRight()){
min.setRight(dataRoot.getRight());
setParent(dataRoot.getRight(),min);
}
//remove a black node,need fix color
if(curMinIsBlack){
if(min!=dataRoot.getRight()){
fixRemove(x,isParent);
}else if(min.getRight()!=null){
fixRemove(min.getRight(),false);
}else{
fixRemove(min,true);
}
}
}else{
setParent(dataRoot.getLeft(),parent);
if(parent.getLeft()==dataRoot){
parent.setLeft(dataRoot.getLeft());
}else{
parent.setRight(dataRoot.getLeft());
}
//current node is black and tree is not empty
if(dataRoot.isBlack() && !(root.getLeft()==null)){
RBTreeNode<T> x = dataRoot.getLeft()==null
? parent :dataRoot.getLeft();
boolean isParent = dataRoot.getLeft()==null;
fixRemove(x,isParent);
}
}
setParent(dataRoot,null);
dataRoot.setLeft(null);
dataRoot.setRight(null);
if(getRoot()!=null){
getRoot().setRed(false);
getRoot().setParent(null);
}
size.decrementAndGet();
return dataRoot.getValue();
}
}
return null;
}
/**
* fix remove action
* @param node
* @param isParent
*/
private void fixRemove(RBTreeNode<T> node,boolean isParent){
RBTreeNode<T> cur = isParent ? null : node;
boolean isRed = isParent ? false : node.isRed();
RBTreeNode<T> parent = isParent ? node : node.getParent();
while(!isRed && !isRoot(cur)){
RBTreeNode<T> sibling = getSibling(cur,parent);
//sibling is not null,due to before remove tree color is balance
//if cur is a left node
boolean isLeft = parent.getRight()==sibling;
if(sibling.isRed() && !isLeft){//case 1
//cur in right
parent.makeRed();
sibling.makeBlack();
rotateRight(parent);
}else if(sibling.isRed() && isLeft){
//cur in left
parent.makeRed();
sibling.makeBlack();
rotateLeft(parent);
}else if(isBlack(sibling.getLeft()) && isBlack(sibling.getRight())){//case 2
sibling.makeRed();
cur = parent;
isRed = cur.isRed();
parent=parent.getParent();
}else if(isLeft && !isBlack(sibling.getLeft())
&& isBlack(sibling.getRight())){//case 3
sibling.makeRed();
sibling.getLeft().makeBlack();
rotateRight(sibling);
}else if(!isLeft && !isBlack(sibling.getRight())
&& isBlack(sibling.getLeft()) ){
sibling.makeRed();
sibling.getRight().makeBlack();
rotateLeft(sibling);
}else if(isLeft && !isBlack(sibling.getRight())){//case 4
sibling.setRed(parent.isRed());
parent.makeBlack();
sibling.getRight().makeBlack();
rotateLeft(parent);
cur=getRoot();
}else if(!isLeft && !isBlack(sibling.getLeft())){
sibling.setRed(parent.isRed());
parent.makeBlack();
sibling.getLeft().makeBlack();
rotateRight(parent);
cur=getRoot();
}
}
if(isRed){
cur.makeBlack();
}
if(getRoot()!=null){
getRoot().setRed(false);
getRoot().setParent(null);
}
}
//get sibling node
private RBTreeNode<T> getSibling(RBTreeNode<T> node,RBTreeNode<T> parent){
parent = node==null ? parent : node.getParent();
if(node==null){
return parent.getLeft()==null ? parent.getRight() : parent.getLeft();
}
if(node==parent.getLeft()){
return parent.getRight();
}else{
return parent.getLeft();
}
}
private boolean isBlack(RBTreeNode<T> node){
return node==null || node.isBlack();
}
private boolean isRoot(RBTreeNode<T> node){
return root.getLeft() == node && node.getParent()==null;
}
/**
* find the successor node
* @param node current node's right node
* @return
*/
private RBTreeNode<T> removeMin(RBTreeNode<T> node){
//find the min node
RBTreeNode<T> parent = node;
while(node!=null && node.getLeft()!=null){
parent = node;
node = node.getLeft();
}
//remove min node
if(parent==node){
return node;
}
parent.setLeft(node.getRight());
setParent(node.getRight(),parent);
//don't remove right pointer,it is used for fixed color balance
//node.setRight(null);
return node;
}
private T addNode(RBTreeNode<T> node){
node.setLeft(null);
node.setRight(null);
node.setRed(true);
setParent(node,null);
if(root.getLeft()==null){
root.setLeft(node);
//root node is black
node.setRed(false);
size.incrementAndGet();
}else{
RBTreeNode<T> x = findParentNode(node);
int cmp = x.getValue().compareTo(node.getValue());
if(this.overrideMode && cmp==0){
T v = x.getValue();
x.setValue(node.getValue());
return v;
}else if(cmp==0){
//value exists,ignore this node
return x.getValue();
}
setParent(node,x);
if(cmp>0){
x.setLeft(node);
}else{
x.setRight(node);
}
fixInsert(node);
size.incrementAndGet();
}
return null;
}
/**
* find the parent node to hold node x,if parent value equals x.value return parent.
* @param x
* @return
*/
private RBTreeNode<T> findParentNode(RBTreeNode<T> x){
RBTreeNode<T> dataRoot = getRoot();
RBTreeNode<T> child = dataRoot;
while(child!=null){
int cmp = child.getValue().compareTo(x.getValue());
if(cmp==0){
return child;
}
if(cmp>0){
dataRoot = child;
child = child.getLeft();
}else if(cmp<0){
dataRoot = child;
child = child.getRight();
}
}
return dataRoot;
}
/**
* red black tree insert fix.
* @param x
*/
private void fixInsert(RBTreeNode<T> x){
RBTreeNode<T> parent = x.getParent();
while(parent!=null && parent.isRed()){
RBTreeNode<T> uncle = getUncle(x);
if(uncle==null){//need to rotate
RBTreeNode<T> ancestor = parent.getParent();
//ancestor is not null due to before before add,tree color is balance
if(parent == ancestor.getLeft()){
boolean isRight = x == parent.getRight();
if(isRight){
rotateLeft(parent);
}
rotateRight(ancestor);
if(isRight){
x.setRed(false);
parent=null;//end loop
}else{
parent.setRed(false);
}
ancestor.setRed(true);
}else{
boolean isLeft = x == parent.getLeft();
if(isLeft){
rotateRight(parent);
}
rotateLeft(ancestor);
if(isLeft){
x.setRed(false);
parent=null;//end loop
}else{
parent.setRed(false);
}
ancestor.setRed(true);
}
}else{//uncle is red
parent.setRed(false);
uncle.setRed(false);
parent.getParent().setRed(true);
x=parent.getParent();
parent = x.getParent();
}
}
getRoot().makeBlack();
getRoot().setParent(null);
}
/**
* get uncle node
* @param node
* @return
*/
private RBTreeNode<T> getUncle(RBTreeNode<T> node){
RBTreeNode<T> parent = node.getParent();
RBTreeNode<T> ancestor = parent.getParent();
if(ancestor==null){
return null;
}
if(parent == ancestor.getLeft()){
return ancestor.getRight();
}else{
return ancestor.getLeft();
}
}
private void rotateLeft(RBTreeNode<T> node){
RBTreeNode<T> right = node.getRight();
if(right==null){
throw new java.lang.IllegalStateException("right node is null");
}
RBTreeNode<T> parent = node.getParent();
node.setRight(right.getLeft());
setParent(right.getLeft(),node);
right.setLeft(node);
setParent(node,right);
if(parent==null){//node pointer to root
//right raise to root node
root.setLeft(right);
setParent(right,null);
}else{
if(parent.getLeft()==node){
parent.setLeft(right);
}else{
parent.setRight(right);
}
//right.setParent(parent);
setParent(right,parent);
}
}
private void rotateRight(RBTreeNode<T> node){
RBTreeNode<T> left = node.getLeft();
if(left==null){
throw new java.lang.IllegalStateException("left node is null");
}
RBTreeNode<T> parent = node.getParent();
node.setLeft(left.getRight());
setParent(left.getRight(),node);
left.setRight(node);
setParent(node,left);
if(parent==null){
root.setLeft(left);
setParent(left,null);
}else{
if(parent.getLeft()==node){
parent.setLeft(left);
}else{
parent.setRight(left);
}
setParent(left,parent);
}
}
private void setParent(RBTreeNode<T> node,RBTreeNode<T> parent){
if(node!=null){
node.setParent(parent);
if(parent==root){
node.setParent(null);
}
}
}
/**
* debug method,it used print the given node and its children nodes,
* every layer output in one line
* @param root
*/
public void printTree(RBTreeNode<T> root){
java.util.LinkedList<RBTreeNode<T>> queue =new java.util.LinkedList<RBTreeNode<T>>();
java.util.LinkedList<RBTreeNode<T>> queue2 =new java.util.LinkedList<RBTreeNode<T>>();
if(root==null){
return ;
}
queue.add(root);
boolean firstQueue = true;
while(!queue.isEmpty() || !queue2.isEmpty()){
java.util.LinkedList<RBTreeNode<T>> q = firstQueue ? queue : queue2;
RBTreeNode<T> n = q.poll();
if(n!=null){
String pos = n.getParent()==null ? "" : ( n == n.getParent().getLeft()
? " LE" : " RI");
String pstr = n.getParent()==null ? "" : n.getParent().toString();
String cstr = n.isRed()?"R":"B";
cstr = n.getParent()==null ? cstr : cstr+" ";
System.out.print(n+"("+(cstr)+pstr+(pos)+")"+"\t");
if(n.getLeft()!=null){
(firstQueue ? queue2 : queue).add(n.getLeft());
}
if(n.getRight()!=null){
(firstQueue ? queue2 : queue).add(n.getRight());
}
}else{
System.out.println();
firstQueue = !firstQueue;
}
}
}
public static void main(String[] args) {
RBTree<String> bst = new RBTree<String>();
bst.addNode("d");
bst.addNode("d");
bst.addNode("c");
bst.addNode("c");
bst.addNode("b");
bst.addNode("f");
bst.addNode("a");
bst.addNode("e");
bst.addNode("g");
bst.addNode("h");
bst.remove("c");
bst.printTree(bst.getRoot());
}
}
代碼調試的時候，printTree輸出格式如下:
d(B)
b(B d LE) g(R d RI)
a(R b LE) e(B g LE) h(B g RI)
f(R e RI)
括號左邊表示元素的內容。括號內的第一個元素表示顏色，B表示black，R表示red；第二個元素表示父元素的值；第三個元素表示左右，LE表示在父元素的左邊。RI表示在父元素的右邊。
第一個元素d是root節點，由於它沒有父節點，所以括號內只有一個元素。
總結
作爲平衡二叉查找樹裏面衆多的實現之一，紅黑樹無疑是最簡潔、實現最爲簡單的。紅黑樹通過引入顏色的概念，通過顏色這個約束條件的使用來保持樹的高度平衡。作爲平衡二叉查找樹，旋轉是一個必不可少的操作。通過旋轉可以降低樹的高度，在紅黑樹裏面還可以轉換顏色。
紅黑樹裏面的插入和刪除的操作比較難理解，這時要注意記住一點：操作之前紅黑樹是平衡的，顏色是符合定義的。在操作的時候就需要向兄弟節點、父節點、侄子節點借調和互換顏色，要達到這個目的，就需要不斷的進行旋轉。所以紅黑樹的插入刪除操作需要不停的旋轉，一旦借調了別的節點，刪除和插入的節點就會達到局部的平衡（局部符合紅黑樹的定義），但是被借調的節點就不會平衡了，這時就需要以被借調的節點爲起點繼續進行調整，直到整棵樹都是平衡的。在整個修復的過程中，插入具體的分爲3種情況，刪除分爲4種情況。
整個紅黑樹的查找，插入和刪除都是O(logN)的，原因就是整個紅黑樹的高度是logN，查找從根到葉，走過的路徑是樹的高度，刪除和插入操作是從葉到根的，所以經過的路徑都是logN。
參考文獻
- Cormen T H, Leiserson C E, Rivest R L, 等. 算法導論（第3版）. 殷建平, 等. 機械工業出版社, 2012.
- Sedgewick R, Wayne K. 算法（第4版）. 謝路雲 譯. 人民郵電出版社, 2012.
- Weiss M A. 數據結構與算法分析（第2版）. 馮舜璽 譯. 機械工業出版社, 2004.
- Knuth D E. 計算機程序設計藝術 卷3：排序與查找（英文版 第2版）. 人民郵電出版社, 2010.