【資料結構和演算法05】 紅-黑樹（看完包懂~）__java

        （友情提示，紅-黑樹是基於二叉搜尋樹的，如果對二叉搜尋樹不瞭解，可以先看看：二叉搜尋樹 ）       

        從第4節的分析中可以看出，二叉搜尋樹是個很好的資料結構，可以快速地找到一個給定關鍵字的資料項目，並且可以快速地插入和刪除資料項目。但是二叉搜尋樹有個很麻煩的問題，如果樹中插入的是隨機資料，則執行效果很好，但如果插入的是有序或者逆序的資料，那麼二叉搜尋樹的執行速度就變得很慢。因為當插入數值有序時，二叉樹就是非平衡的了，排在一條線上，其實就變成了一個鏈表……它的快速尋找、插入和刪除指定資料項目的能力就喪失了。         為了能以較快的時間O(logN)來搜尋一棵樹，需要保證樹總是平衡的（或者至少大部分是平衡的），這就是說對樹中的每個節點在它左邊的後代數目和在它右邊的後代數目應該大致相等。紅-黑樹的就是這樣的一棵平衡樹，對一個要插入的資料項目，插入常式要檢查會不會破壞樹的特徵，如果破壞了，程式就會進行糾正，根據需要改變樹的結構，從而保持樹的平衡。那麼紅-黑樹都有哪些特徵呢。 1.紅-黑樹的特徵

        它主要有兩個特徵：1.節點都有顏色；2.在插入和刪除的過程中，要遵循保持這些顏色的不同排列的規則。首先第一個特徵很好解決，在節點類中店家一個資料欄位，例如boolean型變數，以此來表示節點的顏色資訊。第二個特徵比較複雜，紅-黑樹有它的幾個規則，如果遵循這些規則，那麼樹就是平衡的。紅-黑樹的主要規則如下：

        1.每個節點不是紅色就是黑色的；

        2.根節點總是黑色的；

        3.如果節點是紅色的，則它的子節點必須是黑色的（反之不一定）；

        4.從根節點到分葉節點或空子節點的每條路徑，必須包含相同數目的黑色節點（即相同的黑色高度）。    

        在紅-黑樹中插入的節點都是紅色的，這不是偶然的，因為插入一個紅色節點比插入一個黑色節點違背紅-黑規則的可能性更小。原因是：插入黑色節點總會改變黑色高度（違背規則4），但是插入紅色節點只有一半的機會會違背規則3。另外違背規則3比違背規則4要更容易修正。當插入一個新的節點時，可能會破壞這種平衡性，那麼紅-黑樹是如何修正的呢。

2.平衡性的修正

        紅-黑樹主要通過三種方式對平衡進行修正，改變節點顏色、左旋和右旋。這看起來有點抽象，我們分別來介紹它們。 1.變色

        改變節點顏色比較容易理解，因為它違背了規則3。假設現在有個節點E，然後插入節點A和節點S，節點A在左子節點，S在右子節點，目前是平衡的。如果此時再插一個節點，那麼就出現了不平衡了，因為紅色節點的子節點必須為黑色，但是新插的節點是紅色的。所以這時候就必須改變節點顏色了。所以我們將根的兩個子節點從紅色變為黑色（至於為什麼都要變，下面插入的時候會詳細介紹），將父節點會從黑色變成紅色。可以用如下示意圖表示一下：

2.左旋

        通常左旋操作用於將一個向右傾斜的紅色連結旋轉為向左連結。示意圖如下：

        左旋有個很萌萌噠的動態示意圖，可以方便理解：

3.右旋

        右旋可左旋剛好相反，這裡不再贅述，直接看示意圖：

 

        當然咯，右旋也有個萌萌的動態圖：

        這裡主要介紹了紅-黑樹對平衡的三種修正方式，大家有個感性的認識，那麼什麼時候該修正呢。什麼時候該用哪種修正呢。這將是接下來我們要探討的問題。

3.紅-黑樹的操作
        紅-黑樹的基本操作是添加、刪除和旋轉。對紅-黑樹進行添加或刪除後，可能會破壞其平衡性，會用到哪種旋轉方式去修正呢。我們首先對紅-黑樹的節點做一介紹，然後分別對左旋和右旋的具體實現做一分析，最後我們探討下紅-黑樹的具體操作。
1.紅-黑樹的節點

        紅-黑樹是對二叉搜尋樹的改進，所以其節點與二叉搜尋樹是差不多的，只不過在它基礎上增加了一個boolean型變數來表示節點的顏色，具體看RBNode<T>類：

public class RBNode<T extends Comparable<T>>{boolean color; //顏色T key; //關鍵字(索引值)RBNode<T> left; //左子節點RBNode<T> right; //右子節點RBNode<T> parent; //父節點public RBNode(T key, boolean color, RBNode<T> parent, RBNode<T> left, RBNode<T> right) {this.key = key;this.color = color;this.parent = parent;this.left = left;this.right = right;}public T getKey() {return key;}public String toString() {return "" + key + (this.color == RED? "R" : "B");}}

2.左旋具體實現

        上面對左旋的概念已經有了感性的認識了，這裡就不再贅述了，我們從下面的代碼中結合上面的示意圖，探討一下左旋的具體實現：

/*************對紅/黑樹狀結構節點x進行左旋操作 ******************//* * 左旋示意圖：對節點x進行左旋 *     p                       p *    /                       / *   x                       y *  / \                     / \ * lx  y      ----->       x  ry *    / \                 / \ *   ly ry               lx ly * 左旋做了三件事： * 1. 將y的左子節點賦給x的右子節點,並將x賦給y左子節點的父節點(y左子節點非空時) * 2. 將x的父節點p(非空時)賦給y的父節點，同時更新p的子節點為y(左或右) * 3. 將y的左子節點設為x，將x的父節點設為y */private void leftRotate(RBNode<T> x) {//1. 將y的左子節點賦給x的右子節點，並將x賦給y左子節點的父節點(y左子節點非空時)RBNode<T> y = x.right;x.right = y.left;if(y.left != null) y.left.parent = x;//2. 將x的父節點p(非空時)賦給y的父節點，同時更新p的子節點為y(左或右)y.parent = x.parent;if(x.parent == null) {this.root = y; //如果x的父節點為空白，則將y設為父節點} else {if(x == x.parent.left) //如果x是左子節點x.parent.left = y; //則也將y設為左子節點elsex.parent.right = y;//否則將y設為右子節點}//3. 將y的左子節點設為x，將x的父節點設為yy.left = x;x.parent = y;}

3.右旋具體實現

        上面對右旋的概念已經有了感性的認識了，這裡也不再贅述了，我們從下面的代碼中結合上面的示意圖，探討一下右旋的具體實現：

/*************對紅/黑樹狀結構節點y進行右旋操作 ******************//* * 左旋示意圖：對節點y進行右旋 *        p                   p *       /                   / *      y                   x *     / \                 / \ *    x  ry   ----->      lx  y *   / \                     / \ * lx  rx                   rx ry * 右旋做了三件事： * 1. 將x的右子節點賦給y的左子節點,並將y賦給x右子節點的父節點(x右子節點非空時) * 2. 將y的父節點p(非空時)賦給x的父節點，同時更新p的子節點為x(左或右) * 3. 將x的右子節點設為y，將y的父節點設為x */private void rightRotate(RBNode<T> y) {//1. 將y的左子節點賦給x的右子節點，並將x賦給y左子節點的父節點(y左子節點非空時)RBNode<T> x = y.left;y.left = x.right;if(x.right != null) x.right.parent = y;//2. 將x的父節點p(非空時)賦給y的父節點，同時更新p的子節點為y(左或右)x.parent = y.parent;if(y.parent == null) {this.root = x; //如果x的父節點為空白，則將y設為父節點} else {if(y == y.parent.right) //如果x是左子節點y.parent.right = x; //則也將y設為左子節點elsey.parent.left = x;//否則將y設為右子節點}//3. 將y的左子節點設為x，將x的父節點設為yx.right = y;y.parent = x;}

4.插入操作

        分析完了紅-黑樹中主要的旋轉操作，接下來我們開始分析常見的插入、刪除等操作了。這裡先分析插入操作。 由於紅-黑樹是二叉搜尋樹的改進，所以插入操作的前半工作時相同的，即先找到待插入的位置，再將節點插入，先來看看插入的前半段代碼：

/*********************** 向紅/黑樹狀結構中插入節點 **********************/public void insert(T key) {RBNode<T> node = new RBNode<T>(key, RED, null, null, null);if(node != null) insert(node);}//將節點插入到紅/黑樹狀結構中，這個過程與二叉搜尋樹是一樣的private void insert(RBNode<T> node) {RBNode<T> current = null; //表示最後node的父節點RBNode<T> x = this.root; //用來向下搜尋用的//1. 找到插入的位置while(x != null) {current = x;int cmp = node.key.compareTo(x.key);if(cmp < 0) x = x.left;elsex = x.right;}node.parent = current; //找到了位置，將當前current作為node的父節點//2. 接下來判斷node是插在左子節點還是右子節點if(current != null) {int cmp = node.key.compareTo(current.key);if(cmp < 0)current.left = node;elsecurrent.right = node;} else {this.root = node;}//3. 將它重新修整為一顆紅/黑樹狀結構insertFixUp(node);}

        這與二叉搜尋樹中實現的思路一模一樣，這裡不再贅述，主要看看方法裡面最後一步insertFixUp操作。因為插入後可能會導致樹的不平衡，insertFixUp方法裡主要是分情況討論，分析何時變色，何時左旋，何時右旋。我們先從理論上分析具體的情況，然後再看insertFixUp方法的具體實現。

        如果是第一次插入，由於原樹為空白，所以只會違反紅-黑樹的規則2，所以只要把根節點塗黑即可；如果插入節點的父節點是黑色的，那不會違背紅-黑樹的規則，什麼也不需要做；但是遇到如下三種情況時，我們就要開始變色和旋轉了：

        1. 插入節點的父節點和其叔叔節點（祖父節點的另一個子節點）均為紅色的；

        2. 插入節點的父節點是紅色，叔叔節點是黑色，且插入節點是其父節點的右子節點；

        3. 插入節點的父節點是紅色，叔叔節點是黑色，且插入節點是其父節點的左子節點。

        下面我們先挨個分析這三種情況都需要如何操作，然後再給出實現代碼。

        對於情況1：插入節點的父節點和其叔叔節點（祖父節點的另一個子節點）均為紅色的。此時，肯定存在祖父節點，但是不知道父節點是其左子節點還是右子節點，但是由於對稱性，我們只要討論出一邊的情況，另一種情況自然也與之對應。這裡考慮父節點是祖父節點的左子節點的情況，如下左圖所示：

           

        對於這種情況，我們要做的操作有：將當前節點(4)的父節點(5)和叔叔節點(8)塗黑，將祖父節點(7)塗紅，變成上右圖所示的情況。再將當前節點指向其祖父節點，再次從新的當前節點開始演算法（具體等下看下面的程式）。這樣上右圖就變成了情況2了。

        對於情況2：插入節點的父節點是紅色，叔叔節點是黑色，且插入節點是其父節點的右子節點。我們要做的操作有：將當前節點(7)的父節點(2)作為新的節點，以新的當前節點為支點做左旋操作。完成後如左下圖所示，這樣左下圖就變成情況3了。

     

        對於情況3：插入節點的父節點是紅色，叔叔節點是黑色，且插入節點是其父節點的左子節點。我們要做的操作有：將當前節點的父節點(7)塗黑，將祖父節點(11)塗紅，在祖父節點為支點做右旋操作。最後把根節點塗黑，整個紅-黑樹重新恢複了平衡，如右上圖所示。至此，插入操作完成。

        我們可以看出，如果是從情況1開始發生的，必然會走完情況2和3，也就是說這是一整個流程，當然咯，實際中可能不一定會從情況1發生，如果從情況2開始發生，那再走個情況3即可完成調整，如果直接只要調整情況3，那麼前兩種情況均不需要調整了。故變色和旋轉之間的先後關係可以表示為：變色->左旋->右旋。

        至此，我們完成了全部的插入操作。下面我們看看insertFixUp方法中的具體實現（可以結合上面的分析圖，更加利與理解）：

private void insertFixUp(RBNode<T> node) {RBNode<T> parent, gparent; //定義父節點和祖父節點//需要修整的條件：父節點存在，且父節點的顏色是紅色while(((parent = parentOf(node)) != null) && isRed(parent)) {gparent = parentOf(parent);//獲得祖父節點//若父節點是祖父節點的左子節點，下面else與其相反if(parent == gparent.left) {RBNode<T> uncle = gparent.right; //獲得叔叔節點//case1: 叔叔節點也是紅色if(uncle != null && isRed(uncle)) {setBlack(parent); //把父節點和叔叔節點塗黑setBlack(uncle);setRed(gparent); //把祖父節點塗紅node = gparent; //將位置放到祖父節點處continue; //繼續while，重新判斷}//case2: 叔叔節點是黑色，且當前節點是右子節點if(node == parent.right) {leftRotate(parent); //從父節點處左旋RBNode<T> tmp = parent; //然後將父節點和自己調換一下，為下面右旋做準備parent = node;node = tmp;}//case3: 叔叔節點是黑色，且當前節點是左子節點setBlack(parent);setRed(gparent);rightRotate(gparent);} else { //若父節點是祖父節點的右子節點,與上面的完全相反，本質一樣的RBNode<T> uncle = gparent.left;//case1: 叔叔節點也是紅色if(uncle != null & isRed(uncle)) {setBlack(parent);setBlack(uncle);setRed(gparent);node = gparent;continue;}//case2: 叔叔節點是黑色的，且當前節點是左子節點if(node == parent.left) {rightRotate(parent);RBNode<T> tmp = parent;parent = node;node = tmp;}//case3: 叔叔節點是黑色的，且當前節點是右子節點setBlack(parent);setRed(gparent);leftRotate(gparent);}}//將根節點設定為黑色setBlack(this.root);}

5.刪除操作

        上面探討完了紅-黑樹的插入操作，接下來討論刪除，紅-黑樹的刪除和二叉尋找樹的刪除是一樣的，只不過刪除後多了個平衡的修複而已。我們先來回憶一下二叉搜尋樹的刪除（也可以直接閱讀這篇部落格：二叉搜尋樹）：

        1. 如果待刪除節點沒有子節點，那麼直接刪掉即可；

        2. 如果待刪除節點只有一個子節點，那麼直接刪掉，並用其子節點去頂替它；

        3. 如果待刪除節點有兩個子節點，這種情況比較複雜：首選找出它的後繼節點，然後處理“後繼節點”和“被刪除節點的父節點”之間的關係，最後處理“後繼節點的子節點”和“被刪除節點的子節點”之間的關係。每一步中也會有不同的情況，我們結合下面代碼的分析就能弄清楚，當然了，如果已經弄懂了二叉搜尋樹，那自然自然都能明白，這裡就不贅述了。

        我們來看一下刪除操作的代碼及注釋：

/*********************** 刪除紅/黑樹狀結構中的節點 **********************/public void remove(T key) {RBNode<T> node;if((node = search(root, key)) != null)remove(node);}private void remove(RBNode<T> node) {RBNode<T> child, parent;boolean color;//1. 被刪除的節點“左右子節點都不為空白”的情況if((node.left != null) && (node.right != null)) {//先找到被刪除節點的後繼節點，用它來取代被刪除節點的位置RBNode<T> replace = node;//  1). 擷取後繼節點replace = replace.right;while(replace.left != null) replace = replace.left;//  2). 處理“後繼節點”和“被刪除節點的父節點”之間的關係if(parentOf(node) != null) { //要刪除的節點不是根節點if(node == parentOf(node).left) parentOf(node).left = replace;elseparentOf(node).right = replace;} else { //否則this.root = replace;}//  3). 處理“後繼節點的子節點”和“被刪除節點的子節點”之間的關係child = replace.right; //後繼節點肯定不存在左子節點。parent = parentOf(replace);color = colorOf(replace);//儲存後繼節點的顏色if(parent == node) { //後繼節點是被刪除節點的子節點parent = replace;} else { //否則if(child != null) setParent(child, parent);parent.left = child;replace.right = node.right;setParent(node.right, replace);}replace.parent = node.parent;replace.color = node.color; //保持原來位置的顏色replace.left = node.left;node.left.parent = replace;if(color == BLACK) { //4. 如果移走的後繼節點顏色是黑色，重新修整紅/黑樹狀結構removeFixUp(child, parent);//將後繼節點的child和parent傳進去}node = null;return;}}

        下面我們主要看看方法裡面最後的removeFixUp操作。因為remove後可能會導致樹的不平衡，removeFixUp方法裡主要是分情況討論，分析何時變色，何時左旋，何時右旋。我們同樣先從理論上分析具體的情況，然後再看removeFixUp方法的具體實現。

        從上面的代碼中可以看出，刪除某個節點後，會用它的後繼節點來填上，並且後繼節點會設定為和刪除節點同樣的顏色，所以刪除節點的那個位置是不會破壞平衡的。可能破壞平衡的是後繼節點原來的位置，因為後繼節點拿走了，原來的位置結構改變了，這就會導致不平衡的出現。所以removeFixUp方法中傳入的參數也是後繼節點的子節點和父節點。

        為了方便下文的敘述，我們現在約定：後繼節點的子節點稱為“當前節點”。

        刪除操作後，如果當前節點是黑色的根節點，那麼不用任何操作，因為並沒有破壞樹的平衡性，即沒有違背紅-黑樹的規則，這很好理解。如果當前節點是紅色的，說明剛剛移走的後繼節點是黑色的，那麼不管後繼節點的父節點是啥顏色，我們只要將當前節點塗黑就可以了，紅-黑樹的平衡性就可以恢複。但是如果遇到以下四種情況，我們就需要通過變色或旋轉來恢複紅-黑樹的平衡了。

        1. 當前節點是黑色的，且兄弟節點是紅色的（那麼父節點和兄弟節點的子節點肯定是黑色的）；

        2. 當前節點是黑色的，且兄弟節點是黑色的，且兄弟節點的兩個子節點均為黑色的；

        3. 當前節點是黑色的，且兄弟節點是黑色的，且兄弟節點的左子節點是紅色，右子節點時黑色的；

        4. 當前節點是黑色的，且兄弟節點是黑色的，且兄弟節點的右子節點是紅色，左子節點任意顏色。

        以上四種情況中，我們可以看出2,3,4其實是“當前節點是黑色的，且兄弟節點是黑色的”的三種子集，等會在程式中可以體現出來。現在我們假設當前節點是左子節點（當然也可能是右子節點，跟左子節點相反即可，我們討論一邊就可以了），分別解決上面四種情況：

        對於情況1：當前節點是黑色的，且兄弟節點是紅色的（那麼父節點和兄弟節點的子節點肯定是黑色的）。如左下圖所示：A節點表示當前節點。針對這種情況，我們要做的操作有：將父節點（B）塗紅，將兄弟節點（D）塗黑，然後將當前節點（A）的父節點（B）作為支點左旋，然後當前節點的兄弟節點就變成黑色的情況了（自然就轉換成情況2，3,4的公有特徵了），如右下圖所示：

  

        對於情況2：當前節點是黑色的，且兄弟節點是黑色的，且兄弟節點的兩個子節點均為黑色的。如左下圖所示，A表示當前節點。針對這種情況，我們要做的操作有：將兄弟節點（D）塗紅，將當前節點指向其父節點（B），將其父節點指向當前節點的祖父節點，繼續新的演算法（具體見下面的程式），不需要旋轉。這樣變成了右下圖所示的情況：

  

        對於情況3：當前節點是黑色的，且兄弟節點是黑色的，且兄弟節點的左子節點是紅色，右子節點時黑色的。如左下圖所示，A是當前節點。針對這種情況，我們要做的操作有：把當前節點的兄弟節點（D）塗紅，把兄弟節點的左子節點（C）塗黑，然後以兄弟節點作為支點做右旋操作。然後兄弟節點就變成黑色的，且兄弟節點的右子節點變成紅色的情況（情況4）了。如右下圖：

  

        對於情況4：當前節點是黑色的，且兄弟節點是黑色的，且兄弟節點的右子節點是紅色，左子節點任意顏色。如左下圖所示：A為當前節點，針對這種情況，我們要做的操作有：把兄弟節點（D）塗成父節點的顏色，再把父節點（B）塗黑，把兄弟節點的右子節點（E）塗黑，然後以當前節點的父節點為支點做左旋操作。至此，刪除修複演算法就結束了，最後將根節點塗黑即可。

  

        我們可以看出，如果是從情況1開始發生的，可能情況2，3，4中的一種：如果是情況2，就不可能再出現3和4；如果是情況3，必然會導致情況4的出現；如果2和3都不是，那必然是4。當然咯，實際中可能不一定會從情況1發生，這要看具體情況了。

       至此，我們完成了全部的刪除操作。下面我們看看removeFixUp方法中的具體實現（可以結合上面的分析圖，更加利與理解）：

//node表示待修正的節點，即後繼節點的子節點（因為後繼節點被挪到刪除節點的位置去了）private void removeFixUp(RBNode<T> node, RBNode<T> parent) {RBNode<T> other;while((node == null || isBlack(node)) && (node != this.root)) {if(parent.left == node) { //node是左子節點，下面else與這裡的剛好相反other = parent.right; //node的兄弟節點if(isRed(other)) { //case1: node的兄弟節點other是紅色的setBlack(other);setRed(parent);leftRotate(parent);other = parent.right;}//case2: node的兄弟節點other是黑色的，且other的兩個子節點也都是黑色的if((other.left == null || isBlack(other.left)) && (other.right == null || isBlack(other.right))) {setRed(other);node = parent;parent = parentOf(node);} else {//case3: node的兄弟節點other是黑色的，且other的左子節點是紅色，右子節點是黑色if(other.right == null || isBlack(other.right)) {setBlack(other.left);setRed(other);rightRotate(other);other = parent.right;}//case4: node的兄弟節點other是黑色的，且other的右子節點是紅色，左子節點任意顏色setColor(other, colorOf(parent));setBlack(parent);setBlack(other.right);leftRotate(parent);node = this.root;break;}} else { //與上面的對稱other = parent.left;            if (isRed(other)) {                // Case 1: node的兄弟other是紅色的                  setBlack(other);                setRed(parent);                rightRotate(parent);                other = parent.left;            }            if ((other.left==null || isBlack(other.left)) &&                (other.right==null || isBlack(other.right))) {                // Case 2: node的兄弟other是黑色，且other的倆個子節點都是黑色的                  setRed(other);                node = parent;                parent = parentOf(node);            } else {                if (other.left==null || isBlack(other.left)) {                    // Case 3: node的兄弟other是黑色的，並且other的左子節點是紅色，右子節點為黑色。                      setBlack(other.right);                    setRed(other);                    leftRotate(other);                    other = parent.left;                }                // Case 4: node的兄弟other是黑色的；並且other的左子節點是紅色的，右子節點任意顏色                setColor(other, colorOf(parent));                setBlack(parent);                setBlack(other.left);                rightRotate(parent);                node = this.root;                break;            }}}if (node!=null)        setBlack(node);}

4.完整源碼

        終於分析完了插入和刪除操作的所有東西。另外，紅-黑樹還有一些其他動作，比如：尋找特定值、遍曆、返回最值、銷毀樹等操作我將放到源碼中給大家呈現出來，詳見下面紅-黑樹的完整代碼。

package tree;/** * @description implementation of Red-Black Tree by Java * @author eson_15 * @param <T> * @date 2016-4-18 19:27:28 */public class RBTree<T extends Comparable<T>> {private RBNode<T> root; //根節點private static final boolean RED = false; //定義紅/黑樹狀結構標誌private static final boolean BLACK = true;//內部類：節點類public class RBNode<T extends Comparable<T>>{boolean color; //顏色T key; //關鍵字(索引值)RBNode<T> left; //左子節點RBNode<T> right; //右子節點RBNode<T> parent; //父節點public RBNode(T key, boolean color, RBNode<T> parent, RBNode<T> left, RBNode<T> right) {this.key = key;this.color = color;this.parent = parent;this.left = left;this.right = right;}public T getKey() {return key;}public String toString() {return "" + key + (this.color == RED? "R" : "B");}}public RBTree() {root = null;}public RBNode<T> parentOf(RBNode<T> node) { //獲得父節點return node != null? node.parent : null;}public void setParent(RBNode<T> node, RBNode<T> parent) { //設定父節點if(node != null) node.parent = parent;}public boolean colorOf(RBNode<T> node) { //獲得節點的顏色return node != null? node.color : BLACK;}public boolean isRed(RBNode<T> node) { //判斷節點的顏色return (node != null)&&(node.color == RED)? true : false;}public boolean isBlack(RBNode<T> node) {return !isRed(node);}public void setRed(RBNode<T> node) { //設定節點的顏色if(node != null) node.color = RED;}public void setBlack(RBNode<T> node) {if(node != null) {node.color = BLACK;}} public void setColor(RBNode<T> node, boolean color) {if(node != null)node.color = color;} /***************** 前序走訪紅/黑樹狀結構 *********************/public void preOrder() {preOrder(root);}private void preOrder(RBNode<T> tree) {if(tree != null) {System.out.print(tree.key + &