【算法】红黑树的核心代码实现（java版）

【红黑树的节点类】

package RBTree;



public class TreeUnit {

	public String color="red";
	public boolean isRed=true;
	public float indexNO=0.0f;
	public TreeUnit _parent=null;

	public TreeUnit _leftChild=null;
	public TreeUnit _rightChild=null;

	public boolean isNIL=false;


}

【核心操作类】

package RBTree;

public class RBTreeGen {

	public TreeUnit _rootNode=null;

	public TreeUnit _copyRootNode=null;
/**
 * 获取根节点。
 * */
	public TreeUnit getRootNode(){
		return _rootNode;
	}

	public RBTreeGen(TreeUnit rootNode){
		TreeUnit _rootNode1=new TreeUnit();
        recursion_copyRootNode(rootNode, _rootNode1);
        _rootNode=_rootNode1;
	}

	public RBTreeGen(){}

	private void recursion_copyRootNode(TreeUnit currentUnit,TreeUnit copiedUnit){
		if(currentUnit==null){
			return;
		}
		if(copiedUnit==null){
			copiedUnit=new TreeUnit();
		}
		copiedUnit.color=currentUnit.color;
		copiedUnit.indexNO=currentUnit.indexNO;
		copiedUnit.isRed=currentUnit.isRed;
        if(currentUnit._leftChild!=null){
        	TreeUnit leftChild=new TreeUnit();
        	leftChild._parent=copiedUnit;
        	copiedUnit._leftChild=leftChild;
        	recursion_copyRootNode(currentUnit._leftChild, leftChild);

        }

        if(currentUnit._rightChild!=null){
        	TreeUnit rightChild=new TreeUnit();
        	rightChild._parent=copiedUnit;
        	copiedUnit._rightChild=rightChild;
        	recursion_copyRootNode(currentUnit._rightChild, rightChild);

        }

       return;

	}


	public boolean containsKey(float indexNO){
		search_result=false;


		if(_rootNode==null){
			return false;
		}
		recursion_search(_rootNode, indexNO);
		return search_result;

	}
  private boolean search_result=false;

	private void recursion_search(TreeUnit _currentNode,float indexNO){
		if(_currentNode==null){
			return;
		}
		if(indexNO==_currentNode.indexNO){
			search_result=true;
			return;
		}
		if(indexNO<_currentNode.indexNO){
			if(_currentNode._leftChild==null){
				return;
			}
			recursion_search(_currentNode._leftChild, indexNO);
			return;
		}
		if(indexNO>_currentNode.indexNO){
			if(_currentNode._rightChild==null){
				return;
			}
			recursion_search(_currentNode._rightChild, indexNO);
		}

	}
	private TreeUnit recursion_search_node(TreeUnit _currentNode,float indexNO){
		if(_currentNode==null){
			return null;
		}
		if(indexNO==_currentNode.indexNO){

			return _currentNode;
		}
		if(indexNO<_currentNode.indexNO){
			if(_currentNode._leftChild==null){
				return null;
			}
			return recursion_search_node(_currentNode._leftChild, indexNO);

		}
		if(indexNO>_currentNode.indexNO){
			if(_currentNode._rightChild==null){
				return null;
			}
			return recursion_search_node(_currentNode._rightChild, indexNO);
		}
		return null;
	}

private TreeUnit search_node(float indexNO){
	return recursion_search_node(_rootNode, indexNO);
}
	public boolean insert(float indexNO){
		if(_rootNode==null){
			_rootNode=new TreeUnit();
			_rootNode.indexNO=indexNO;
			_rootNode.isRed=false;
			return true;
		}
		TreeUnit parentUnit=recursion_search_fitParentNode(_rootNode, indexNO);
		if(parentUnit==null){
			//--树为空
			return false;

		}
		TreeUnit minNode=new TreeUnit();
		minNode.isRed=true;
		minNode.indexNO=indexNO;
		minNode._parent=parentUnit;
		if(indexNO< parentUnit.indexNO){
			parentUnit._leftChild=minNode;

		}
		else if(indexNO>parentUnit.indexNO){
			parentUnit._rightChild=minNode;
		}
		else{
			return false;
		}


		recursion_fixup_after_insert(minNode);
		return true;


	}
	private void recursion_fixup_after_insert(TreeUnit newNode){
		if(newNode==null){
			return;
		}
		//--假如这个没有父节点---即是根节点，那么直接渲染成黑色，然后结束。
		if(newNode._parent==null){
			newNode.isRed=false;
			return;
		}
		//--假如父亲节点就是黑色的，那么还需要调整吗？立刻结束
		if(newNode._parent.isRed==false){
			return;
		}
		//--假如父亲节点是红色，那么必然有一个祖父节点，该节点必须为黑色（我们假设是在一颗红黑树上面进行局部调整的，
		//只因为加入newNode了才违反规则，即，其他部分一定满足红黑树的性质，所以有祖父节点必然为黑色节点的推论。）
		if(newNode._parent==null||newNode._parent._parent==null){
			return;//--这根本不是红黑树，退出
		}
		TreeUnit currentNode=newNode;
		TreeUnit parentNode=newNode._parent;
		TreeUnit grandFatherNode=parentNode._parent;

		boolean isLeft_son=true;
		boolean isLeft_father=true;



		if(parentNode._rightChild!=null&&parentNode._rightChild.indexNO==currentNode.indexNO){
			isLeft_son=false;
		}
		if(grandFatherNode._rightChild!=null&&grandFatherNode._rightChild.indexNO==parentNode.indexNO){
			isLeft_father=false;
		}
		//--可以看到最多只有四中情况，下面分成四中情况进行调整，在我的博客（csdn---码农下的天桥里面会有配图说明）

		//父节点红，为祖父的左边分支，目前节点为红，为父节点的右边分支，于是我们需要调整这个子树，变成符合规范。
		//步骤：以父节点为支点，左旋；二、以祖父节点为支点，右旋；三、这时候新节点就是子树的根节点了，新节点为红，左右子节点都
		//变成黑色。然后以新节点为准再递归调整。
		if(isLeft_son==false&&isLeft_father==true){
			___turnLeft(parentNode);
			___turnRight(grandFatherNode);
			//--渲染颜色
			currentNode.isRed=true;
			parentNode.isRed=false;
			grandFatherNode.isRed=false;
			recursion_fixup_after_insert(currentNode);
			return;
		}
		//父节点红，为祖父的左边分支，目前节点为红，为父节点的左边分支，于是我们需要调整这个子树，变成符合规范。
		//步骤：二、以祖父节点为支点，右旋；三、这时候新节点就是子树的根节点了，新节点为红，左右子节点都
		//变成黑色。然后以新节点为准再递归调整。
		if(isLeft_father==true&&isLeft_son==true){
			___turnRight(grandFatherNode);
			//--颜色渲染
			currentNode.isRed=false;
			parentNode.isRed=true;
			grandFatherNode.isRed=false;
			recursion_fixup_after_insert(parentNode);
			return;
		}

		//父节点红，为祖父的右边边分支，目前节点为红，为父节点的左边分支，于是我们需要调整这个子树，变成符合规范。
		//步骤：以父节点为支点，右旋；二、以祖父节点为支点，左旋；三、这时候新节点就是子树的根节点了，新节点为红，左右子节点都
		//变成黑色。然后以新节点为准再递归调整。
		if(isLeft_father==false&&isLeft_son==true){
			___turnRight(parentNode);
			___turnLeft(grandFatherNode);
			//颜色渲染
			currentNode.isRed=true;
			parentNode.isRed=false;
			grandFatherNode.isRed=false;
			recursion_fixup_after_insert(currentNode);
			return;
		}
		//父节点红，为祖父的右边边分支，目前节点为红，为父节点的右边分支，于是我们需要调整这个子树，变成符合规范。
		//步骤：二、以祖父节点为支点，左旋；三、这时候新节点就是子树的根节点了，新节点为红，左右子节点都
		//变成黑色。然后以新节点为准再递归调整。
		if(isLeft_father==false&&isLeft_son==false){
			___turnLeft(grandFatherNode);
			//颜色渲染
			currentNode.isRed=false;
			parentNode.isRed=true;
			grandFatherNode.isRed=false;
			recursion_fixup_after_insert(parentNode);
			return;

		}

		return;


	}

	public boolean ___turnLeft(float indexNO){
		 TreeUnit node= search_node(indexNO);
		 return ___turnLeft(node);
	}

	public boolean ___turnRight(float indexNO){
		TreeUnit currentNode=search_node(indexNO);
return ___turnRight(currentNode);
	}
	/**
	 * 将节点向右旋转
	 * */
public boolean ___turnRight(TreeUnit currentNode){


	if(currentNode==null){
		return false;
	}
	if(currentNode._leftChild==null){
		return false;
	}

	//--假如父节点为空，那么：
	TreeUnit originLeftChild=currentNode._leftChild;
	if(currentNode._parent==null){
		originLeftChild._parent=null;
		currentNode._leftChild=originLeftChild._rightChild;
		originLeftChild._rightChild=currentNode;

		if(currentNode._leftChild!=null){
			currentNode._leftChild._parent=currentNode;
		}

		currentNode._parent=originLeftChild;
		_rootNode=originLeftChild;
		return true;
	}
	else{

		boolean isLeft=true;
		if(currentNode._parent._rightChild!=null&¤tNode._parent._rightChild.indexNO==currentNode.indexNO){
			isLeft=false;
		}
		if(isLeft==true){
			currentNode._parent._leftChild=originLeftChild;
		}
		else{
			currentNode._parent._rightChild=originLeftChild;
		}
		originLeftChild._parent=currentNode._parent;
		currentNode._leftChild=originLeftChild._rightChild;
		if(currentNode._leftChild!=null){
			currentNode._leftChild._parent=currentNode;
		}
		originLeftChild._rightChild=currentNode;
		currentNode._parent=originLeftChild;
		return true;
	}
}
/**
 * 将节点向左旋转
 * */
	public boolean ___turnLeft(TreeUnit currentNode){

		if(currentNode==null){
			return false;
		}
		if(currentNode._rightChild==null){
			return false;
		}

		//--假如父节点为空，那么：
		TreeUnit originRightChild=currentNode._rightChild;
		if(currentNode._parent==null){
			originRightChild._parent=null;
			currentNode._rightChild=originRightChild._leftChild;
			originRightChild._leftChild=currentNode;
			if(currentNode._rightChild!=null){
				currentNode._rightChild._parent=currentNode;
			}
			currentNode._parent=originRightChild;
			_rootNode=originRightChild;
			return true;
		}
		else{

			boolean isLeft=true;
			if(currentNode._parent._rightChild!=null&¤tNode._parent._rightChild.indexNO==currentNode.indexNO){
				isLeft=false;
			}
			if(isLeft==true){
				currentNode._parent._leftChild=originRightChild;
			}
			else{
				currentNode._parent._rightChild=originRightChild;
			}
			originRightChild._parent=currentNode._parent;
			currentNode._rightChild=originRightChild._leftChild;
			if(currentNode._rightChild!=null){
				currentNode._rightChild._parent=currentNode;
			}
			originRightChild._leftChild=currentNode;
			currentNode._parent=originRightChild;
			return true;
		}

	}

	public boolean ___insert(float indexNO){
		if(_rootNode==null){
			_rootNode=new TreeUnit();
			_rootNode.indexNO=indexNO;
			_rootNode.isRed=false;
			return true;
		}
		TreeUnit parentUnit=recursion_search_fitParentNode(_rootNode, indexNO);
		if(parentUnit==null){
			//--树为空
			return false;

		}
		TreeUnit minNode=new TreeUnit();
		minNode.isRed=true;
		minNode.indexNO=indexNO;
		minNode._parent=parentUnit;
		if(indexNO< parentUnit.indexNO){
			parentUnit._leftChild=minNode;

		}
		else if(indexNO>parentUnit.indexNO){
			parentUnit._rightChild=minNode;
		}
		else{
			return false;
		}
		return false;

	}
	public void ___fillRed(float indexNO){
		TreeUnit node=search_node(indexNO);
		if(node!=null){
			node.isRed=true;
			node.color="red";
		}


	}

	public void ___fillBlack(float indexNO){
		TreeUnit node=search_node(indexNO);
		if(node!=null){
			node.isRed=false;
			node.color="black";
		}
		}


	/**
	 * 请先搜索到需要添加到的节点,即父节点。
	 * */
	private TreeUnit recursion_search_fitParentNode(TreeUnit _currentUnit,float indexNO){
		if(_currentUnit==null){
			return null;
		}
		if(indexNO< _currentUnit.indexNO){
			if(_currentUnit._leftChild==null){
				return _currentUnit;
			}
			else{
				return recursion_search_fitParentNode(_currentUnit._leftChild, indexNO);
			}
		}
		if(indexNO>_currentUnit.indexNO){
			if(_currentUnit._rightChild==null){
				return _currentUnit;
			}
			else{
				return recursion_search_fitParentNode(_currentUnit._rightChild, indexNO);
			}
		}
		return null;
	}
public boolean delete(float indexNO){

	TreeUnit originNode=search_node(indexNO);
	TreeUnit rec_node=null;
	TreeUnit nilNode=new TreeUnit();
	nilNode.isNIL=true;
	nilNode.isRed=false;
	if(originNode==null){
		return false;
	}
	//--从目前需要删除的节点寻找真正需要删除的节点并且删除。
    TreeUnit realDeletedNode=originNode;
    if(originNode._rightChild==null){
    	realDeletedNode=originNode;
    }
    else{
    	realDeletedNode=recursion_search_real_deletedNode(originNode._rightChild);
    }
    //--从几种情况先删除相关节点：

    /**
     * 当前节点就是需要删除的节点。
     * */
    /**
     * 根据寻找最右侧最小节点为真正需要删除节点的算法，当当前节点与真正需要删除节点为同一个时候，该节点不可能拥有右节点。
     * */
    if(realDeletedNode.indexNO==originNode.indexNO){


    	TreeUnit parentNode=originNode._parent;

    	/**
    	 * 假设当前节点为跟节点。
    	 * */
    	if(parentNode==null){
    		/**
    		 * 没有左子节点,即当前红黑树只有一个根节点，直接清空红黑树，不需要对树进行调整。
    		 * */
    		if(originNode._leftChild==null){
    			_rootNode=null;
    			rec_node=null;
    			return true;
    		}
    		/**
    		 * 假如有一个根节点及有左子结点，那么根据红黑树的性质来推导，这种情况下只可能有一个黑色根节点及红色左子节点。
    		 *
    		 * */
    		else{
    			_rootNode=originNode._leftChild;
    			_rootNode._parent=null;
    			_rootNode.isRed=false;
    			return true;

    		}
    	}
    	/**
    	 * 当前父节点不为空的时候，可以推导根据红黑树规则，之前寻找右侧最小节点为真实删除节点的规则等确定，
    	 * 当当前节点与真实删除节点为同一个节点时候，该节点没有右子节点，且：
    	 * 1、当前节点颜色为红色时候，没有左子结点；
    	 * 2、当前节点颜色为黑色时候，可能有红色的左子结点。
    	 * */
    	else if(parentNode!=null){
    		boolean isLeft=false;
    		if(parentNode._leftChild!=null&&parentNode._leftChild.indexNO==originNode.indexNO){
    			isLeft=true;
    		}
    		if(originNode.isRed==true){
    			if(isLeft==true){
    				parentNode._leftChild=null;

    			}
    			else{
    				parentNode._rightChild=null;
    			}
    			return true;//--这种情况，红黑树性质无任何改变，无须调整。
    		}
    		/**======为：黑色节点===**/
    		else{
    			boolean hasLeftChild=false;
    			if(originNode._leftChild!=null){
    				hasLeftChild=true;
    			}

    			if(isLeft==true){
    				parentNode._leftChild=originNode._leftChild;
    				if(originNode._leftChild!=null){
    					originNode._leftChild._parent=parentNode;
    				}
    			}
    			else if(isLeft==false){
    				parentNode._rightChild=originNode._leftChild;
    				if(originNode._leftChild!=null){
    					originNode._leftChild._parent=parentNode;
    				}
    			}
    			/**
    			 * 当删除的真实节点为黑色，并且拥有一个左子结点（红色）时候，该左子结点作为后继节点，参与到后续的修复调整工作中。
    			 * */
    			if(hasLeftChild==true){
    				if(isLeft==true){
    					recursion_fixup_afterDeletion(parentNode._leftChild);
    				}
    				else{
    					recursion_fixup_afterDeletion(parentNode._rightChild);

    				}

    				return true;
    			}
    			/**
    			 * 当删除的真实节点为黑色，但没有左子结点时候，只能将NIL节点拿出来参与到后续的修复调整工作中去。
    			 * */
    			else{
    				nilNode._parent=parentNode;
    				if(isLeft==true){
    					parentNode._leftChild=nilNode;
    					recursion_fixup_afterDeletion(parentNode._leftChild);
    				}
    				else{
    					parentNode._rightChild=nilNode;
    					recursion_fixup_afterDeletion(parentNode._rightChild);

    				}
                    delNILNode(nilNode);

    				return true;

    			}
    		}

    	}
    	/*

    	if(parentNode!=null){
    		boolean isLeft=true;
    		if(parentNode._rightChild!=null&&parentNode._rightChild.indexNO==originNode.indexNO){
    			isLeft=false;
    		}
    		if(isLeft==true){

    			if(originNode._leftChild!=null){
    				parentNode._leftChild=originNode._leftChild;
    				originNode._leftChild._parent=parentNode;
    				rec_node=originNode._leftChild;
    			}
    			else{
    				parentNode._leftChild=nilNode;
    				nilNode._parent=parentNode;
    				rec_node=nilNode;

    			}

    		}
    		else{
    			parentNode._rightChild=null;
    			if(originNode._leftChild!=null){
    				parentNode._rightChild=originNode._leftChild;
    				originNode._leftChild._parent=parentNode;
    				rec_node=originNode._leftChild;
    			}
    			else{
    				nilNode._parent=parentNode;
    				parentNode._rightChild=nilNode;
    				rec_node=nilNode;
    			}
    		}

    		originNode=null;


    	}

    	else{


			if(originNode._leftChild==null&&originNode._rightChild==null){
				_rootNode=null;
				rec_node=null;

			}
			else if(originNode._rightChild!=null){
				_rootNode=originNode._rightChild;
				originNode._rightChild._parent=null;
				_rootNode._leftChild=originNode._rightChild._leftChild;
				if(_rootNode._leftChild!=null){
					_rootNode._leftChild._parent=_rootNode._leftChild;
				}


			}

			else{
				_rootNode=originNode._leftChild;
				originNode._leftChild._parent=null;

			}
    		_rootNode=null;
    	}*/
    }
    /**
     * 当前节点与需要删除的节点不一样,可以推断，
     * 1、当前节点为真实删除节点的父节点时，真实删除节点不可能有左子结点，并且满足：
     * 1A：真实删除节点颜色为红色时，不可能拥有右子节点；
     * 1B：真实删除节点为黑色时，可能拥有红色右节点。
     * 2、当前节点不是真实删除节点父亲时，真实删除节点不可能拥有左子节点，并且满足：
     * 2A：真实删除节点颜色为红色时候，不可能拥有右子节点；
     * 2B：真实删除节点为黑色时，可能拥有右子节点（红色）。
     *
     * 上面两种情况其实可以合并为一起。
     *
     * */
    else{


    	originNode.indexNO=realDeletedNode.indexNO;
    	TreeUnit parentNode=realDeletedNode._parent;
    	boolean isLeft=true;
    	if(parentNode._rightChild!=null&&parentNode._rightChild.indexNO==realDeletedNode.indexNO){
    		isLeft=false;
    	}
    	/**
    	 * 当真实节点为红色时，不可能拥有子节点，直接删除，无须调整。
    	 * */
    	if(realDeletedNode.isRed==true){
    		if(isLeft==true){
    			parentNode._leftChild=null;
    			return true;
    		}
    		else{
    			parentNode._rightChild=null;
    			return true;
    		}
    	}
    	/**
    	 * 当真实节点为黑色并且拥有红色右子节点时，删除真实节点，将右子节点提升到同样位置，右子节点参与到位置调整。
    	 * */
    	if(realDeletedNode.isRed==false&&realDeletedNode._rightChild!=null&&realDeletedNode._rightChild.isNIL==false){
    		if(isLeft==true){
    			parentNode._leftChild=realDeletedNode._rightChild;
    			realDeletedNode._rightChild._parent=parentNode;
    			recursion_fixup_afterDeletion(realDeletedNode._leftChild);
    			return true;
    		}
    		else{
    			System.out.println("【当真实节点为黑色并且拥有红色右子节点时，删除真实节点，将右子节点提升到同样位置，右子节点参与到位置调整】");
    			parentNode._rightChild=realDeletedNode._rightChild;
    			realDeletedNode._rightChild._parent=parentNode;
    			recursion_fixup_afterDeletion(parentNode._rightChild);
    			return true;

    		}
    	}
    	/**
    	 * 当真实节点为黑色并且没有子节点（除了NIL节点）时，那么将NIL节点放出来作为后继节点参与位置调整。
    	 * */
    	if(realDeletedNode.isRed==false&&(realDeletedNode._rightChild==null||(realDeletedNode._rightChild!=null&&realDeletedNode._rightChild.isNIL==true))){

    		nilNode._parent=parentNode;
    		if(isLeft==true){
    			parentNode._leftChild=nilNode;

    		}
    		else{
    			parentNode._rightChild=nilNode;

    		}
    		//System.out.println("进入【当真实节点为黑色并且没有子节点（除了NIL节点）时，那么将NIL节点放出来作为后继节点参与位置调整】");
    		recursion_fixup_afterDeletion(nilNode);
    		delNILNode(nilNode);
    		return true;
    	}


/*
    	if(parentNode._rightChild!=null&&parentNode._rightChild.indexNO==realDeletedNode.indexNO){
    		if(realDeletedNode._rightChild!=null){realDeletedNode._rightChild._parent=parentNode;}
    		parentNode._rightChild=realDeletedNode._rightChild;
    		realDeletedNode=null;
    	}
    	else{
    		if(realDeletedNode._rightChild!=null){
    			realDeletedNode._rightChild._parent=parentNode;
    		}
    		parentNode._leftChild=realDeletedNode._rightChild;
    		realDeletedNode=null;
    	}
    	*/


    }


	return true;

}

/**
 * 由于原来的数据结构算法里面没有考虑nilnode，所以在删除操作时候需要nilNode参与操作后，必须
 * 删除该参与操作的nilNode
 * */
private void delNILNode(TreeUnit nilNode){
	if(nilNode==null){
		return;
	}
	if(nilNode._parent==null){
		return;
	}
	TreeUnit parentNode=nilNode._parent;
	if(parentNode._leftChild!=null&&parentNode._leftChild.isNIL==true){
		parentNode._leftChild=null;
	}
	if(parentNode._rightChild!=null&&parentNode._rightChild.isNIL==true){
		parentNode._rightChild=null;
	}
}
private TreeUnit recursion_search_real_deletedNode(TreeUnit currentUnit){
	if(currentUnit==null){
		return null;
	}
	if(currentUnit._rightChild==null&¤tUnit._leftChild==null){
		return currentUnit;
	}
	else
	if(currentUnit._leftChild!=null){
		return recursion_search_real_deletedNode(currentUnit._leftChild);
	}
	else{
		return currentUnit;
	}
}




private void recursion_fixup_afterDeletion(TreeUnit currentUnit){

if(currentUnit==null){
	return;
}
if(currentUnit._parent==null){
	currentUnit.isRed=false;
	return;
}
if(currentUnit.isRed==true){
	currentUnit.isRed=false;
	return;
}
/**
 * 一般情况，简单的可以直接完成的情况都考虑到了，下面考虑主要是删除黑色节点情况下需要继续递归调整结构的情况。注意，假如
 * 删除的黑色节点下面没有任何节点---错了，下面是有两个NIL节点，空节点的，届时只需要将NIL节点作为后继节点加到原来父节点的下面,进行运算，
 * 调整结束后再删除这个辅助节点NIL就ok了，反正每一个节点都至少有一个NIL，NIL是无处不在的。
 * */
boolean isLeft=true;
//---后继节点是空节点，特殊处理
if(currentUnit.isNIL==true){
	if(currentUnit._parent._leftChild.isNIL==true){
		isLeft=true;
	}
	else{
		isLeft=false;
	}
}
//--否则，一般方式判断
else{
	if(currentUnit._parent._leftChild.indexNO==currentUnit.indexNO){
		isLeft=true;
	}
	else{
		isLeft=false;
	}
}
TreeUnit grandFatherNode=null;
TreeUnit parentNode=currentUnit._parent;
float parentIndexNO=parentNode.indexNO;
TreeUnit brotherNode=null;//--兄弟节点。
TreeUnit nearNePhewNode=null;//近侄子节点
TreeUnit farNephewNode=null;//远侄子节点

grandFatherNode=parentNode._parent;
boolean isGrandFatherLeft=true;
if(grandFatherNode!=null){
	if(grandFatherNode._rightChild!=null&&grandFatherNode._rightChild.indexNO==parentIndexNO){
		isGrandFatherLeft=false;
	}
}

if(parentNode!=null){
	grandFatherNode=parentNode._parent;
}
if(isLeft==true){
	brotherNode=currentUnit._parent._rightChild;
	nearNePhewNode=brotherNode._leftChild;
	farNephewNode=brotherNode._rightChild;
}
else{
	brotherNode=currentUnit._parent._leftChild;
	nearNePhewNode=brotherNode._rightChild;
	farNephewNode=brotherNode._leftChild;
}
/**
 *如果这个双黑色结点的兄弟结点以及两个侄子结点都是黑色的，那么我们就将它的兄弟结点染为红色之后将这个记号朝树根的方向移动一步。
 * */
boolean isCaseB=false;

if(brotherNode.isRed==false){
	if(((nearNePhewNode!=null&&nearNePhewNode.isRed==true)||(farNephewNode!=null&&farNephewNode.isRed==true))){
		isCaseB=false;
	}
	else{
		isCaseB=true;
	}
}
if(isCaseB==true){

	brotherNode.isRed=true;
	recursion_fixup_afterDeletion(parentNode);
	return;
}
/**
 * 如果带记号的结点的兄弟结点是红色的，那么我们就进行一次旋转操作并改变结点颜色。
 * */
boolean isCaseC=false;
if(brotherNode.isRed==true){
	isCaseC=true;
}
if(isCaseC==true){
	if(isLeft==true){
		//--现有节点在左边，兄弟在右边，兄弟渲染成黑色，父节点渲染成红色，将父节点左旋
	   TreeUnit	brotherLeftChild=brotherNode._leftChild;

	   brotherNode._leftChild=parentNode;
	   parentNode._parent=brotherNode;

	   parentNode._rightChild=brotherLeftChild;
	   if(brotherLeftChild!=null){
		   brotherLeftChild._parent=parentNode;
	   }

	   parentNode.isRed=true;
	   brotherNode.isRed=false;
	   brotherNode._parent=grandFatherNode;
	   if(grandFatherNode!=null){
		   if(isGrandFatherLeft==true){
			   grandFatherNode._leftChild=brotherNode;
		   }
		   else{
			   grandFatherNode._rightChild=brotherNode;
		   }
	   }
	   else{
		   _rootNode=brotherNode;
	   }
	   recursion_fixup_afterDeletion(currentUnit);
	   return;

	}

	else{
	//--现有节点在右边，兄弟在左边，	兄弟渲染成黑色，父节点渲染成红色，将父节点右旋
	 TreeUnit brotherRightChild=brotherNode._rightChild;

	 brotherNode._rightChild=parentNode;
	 parentNode._parent=brotherNode;

	 parentNode._leftChild=brotherRightChild;
	 if(brotherRightChild!=null){
		 brotherRightChild._parent=parentNode;
	 }
	 brotherNode.isRed=false;
	 parentNode.isRed=true;
	 brotherNode._parent=grandFatherNode;
	   if(grandFatherNode!=null){
		   if(isGrandFatherLeft==true){
			   grandFatherNode._leftChild=brotherNode;
		   }
		   else{
			   grandFatherNode._rightChild=brotherNode;
		   }
	   }
	   else{
		   _rootNode=brotherNode;
	   }


		recursion_fixup_afterDeletion(currentUnit);
		return;

	}



}
/**
 * 最终，我们遇到了双黑色结点有一个黑色兄弟结点并至少一个侄子结点是红色的情况。
 * 我们下面给出一个结点x的近侄子结点（near nephew）的定义：
 * 如果x是其父结点的左子结点，那么x的兄弟结点的左子结点为x的近侄子结点，
 * 否则x的兄弟结点的右子结点为x的近侄子结点；而另一 个侄子结点则为x的远侄子结点（far nephew）。
 * （在下面的图解中可以看出，x的近侄子结点要比它的远侄子结点距离x更近。）
 *
 * */
boolean isCaseD=false;
boolean isCaseD_i=false;
boolean isCaseD_ii=false;
if(brotherNode.isRed==false){
	if(nearNePhewNode!=null&&nearNePhewNode.isRed==true){
		isCaseD=true;

	}
	else if(farNephewNode!=null&&farNephewNode.isRed==true){
		isCaseD=true;
	}
}
if(isCaseD==true){
	if(farNephewNode!=null&&farNephewNode.isRed==true){
		isCaseD_ii=true;
	}
	else if(nearNePhewNode!=null&&nearNePhewNode.isRed==true){
		isCaseD_i=true;

	}
}
//--开始转换。
boolean partRootIsRed=false;
//--记下局部根节点的原本颜色
if(isCaseD==true){
	partRootIsRed= brotherNode._parent.isRed;
}


if(isCaseD_i==true){
	TreeUnit tmpLeftChild=nearNePhewNode._leftChild;
	TreeUnit tmpRightChild=nearNePhewNode._rightChild;


	if(isLeft==true){

		/*brotherNode._leftChild=tmpRightChild;
		if(tmpRightChild!=null){
			tmpRightChild._parent=brotherNode;
		}*/
		nearNePhewNode._leftChild=parentNode;
		parentNode._parent=nearNePhewNode;
		nearNePhewNode._rightChild=brotherNode;
		brotherNode._parent=nearNePhewNode;
		parentNode._rightChild=tmpLeftChild;
		if(tmpLeftChild!=null){
			tmpLeftChild._parent=parentNode;
		}
		brotherNode._leftChild=tmpRightChild;
		if(tmpRightChild!=null){
			tmpRightChild._parent=brotherNode;
		}
		parentNode.isRed=partRootIsRed;
		nearNePhewNode.isRed=false;
		nearNePhewNode._parent=grandFatherNode;
		if(grandFatherNode!=null){
			if(isGrandFatherLeft==true){
				grandFatherNode._leftChild=nearNePhewNode;
			}
			else{
				grandFatherNode._rightChild=nearNePhewNode;
			}
		}

		if(nearNePhewNode._parent==null){
			_rootNode=nearNePhewNode;
		}
		return;

	}
	else{

		nearNePhewNode._leftChild=brotherNode;
		brotherNode._parent=nearNePhewNode;
		nearNePhewNode._rightChild=parentNode;
		parentNode._parent=nearNePhewNode;
		brotherNode._rightChild=tmpLeftChild;
		if(tmpLeftChild!=null){
			tmpLeftChild._parent=brotherNode;
		}
		parentNode._leftChild=tmpRightChild;
		if(tmpRightChild!=null){
			tmpRightChild._parent=parentNode;
		}
		nearNePhewNode._parent=grandFatherNode;
		parentNode.isRed=false;
		nearNePhewNode.isRed=partRootIsRed;
		if(grandFatherNode!=null){
			if(isGrandFatherLeft==true){
				grandFatherNode._leftChild=nearNePhewNode;
			}
			else{
				grandFatherNode._rightChild=nearNePhewNode;
			}
		}
		if(nearNePhewNode._parent==null){
			_rootNode=nearNePhewNode;
		}
		return;
	}


}
if(isCaseD_ii==true){
	if(isLeft==true){


     TreeUnit tmpChild=brotherNode._leftChild;
     brotherNode._leftChild=parentNode;
     parentNode._parent=brotherNode;
     parentNode._rightChild=tmpChild;
     if(tmpChild!=null){
    	 tmpChild._parent=parentNode;
     }
     brotherNode._parent=grandFatherNode;
     if(grandFatherNode!=null){
    	 if(isGrandFatherLeft==true){
    		 grandFatherNode._leftChild=brotherNode;
    	 }
    	 else{
    		 grandFatherNode._rightChild=brotherNode;
    	 }

     }
     brotherNode.isRed=partRootIsRed;
     parentNode.isRed=false;
     farNephewNode.isRed=false;
		if(brotherNode._parent==null){
			_rootNode=brotherNode;
		}
     return;
	}
	else{



		TreeUnit tmpChild=brotherNode._rightChild;
		brotherNode._rightChild=parentNode;
		parentNode._parent=brotherNode;
		parentNode._leftChild=tmpChild;
		if(tmpChild!=null){
			tmpChild._parent=parentNode;
		}
		parentNode.isRed=false;
		farNephewNode.isRed=false;
		brotherNode._parent=grandFatherNode;
		brotherNode.isRed=partRootIsRed;
		if(grandFatherNode!=null){
			if(isGrandFatherLeft==true){
				grandFatherNode._leftChild=brotherNode;
			}
			else{
				grandFatherNode._rightChild=brotherNode;
			}
		}
		if(brotherNode._parent==null){
			_rootNode=brotherNode;
		}
		return;
	}
}

}


}