红黑树(RBTREE)之上-------构造红黑树
该怎么说呢，现在写代码的速度还是很快的，很高兴，o(^▽^)o。
光棍节到了，早上没忍住，手贱了一般，看到*D的优惠，买了个机械键盘，晚上就到了，敲着还是很舒服的，和老婆炫耀了一把哈哈。
光棍节再去*mall买个，带着上班用。
正题，构造红黑树，就是节点的插入与调整，具体的理论我就不说了，图我也不画了，别人画的很好，我在纸上画的我自己都不想看。
贴几个网址作为参考吧：
参考的文档：1.http://www.cnblogs.com/zhb-php/p/5504481.html (推荐)
2.http://www.cnblogs.com/skywang12345/p/3245399.html 参考，写的太详细了，反而不适合当文档
3.http://blog.csdn.net/v_july_v/article/details/6284050 这个刚好作为测试的参考图
这次的变量命名基本注意了，不过有些以前写的拿过来改改，懒得去把所有的都改了，写这个好像没有什么收获，好像数据结构基本的一些常用的都写了，还有个hash表下次写。
最近工作应该算是忙吧，但是做的都是偏测试的，更希望去写代码来锻炼自己。另一方面，解决问题感觉啥事都要靠自己啊，别人还是不靠谱的，以后尽量能不问别人就别去问了，感觉自己都烦了，问了别人解决不了,浪费大家的时间最后还是要靠自己去解决。不爽。。。
环境：qt5
语言：c
代码：head_file：rb_func.h
#ifndef RB_MAIN
#define RB_MAIN #define DEBUG 1
#define RED 1
#define BLACK 0
#define R RED
#define B BLACK
#define OK 0
#define ERR -1 #if 1
#define Left 1
#define Right -1
#endif
#ifndef NULL
#define NULL 0
#endif
#define PRINTTREEINIT(a)\
printf("------------------init Tree begin-------------\n");\
PrintBTree(a);\
printf("------------------init Tree end-------------\n");
#define PRINTTREEAVL(a)\
printf("------------------AVL Tree begin-------------\n");\
PrintBTree(a);\
printf("------------------AVL Tree end-------------\n"); #define PRINTTREEDEL(a)\
printf("------------------after del node Tree begin-------------\n");\
PrintBTree(a);\
printf("------------------after del nodeTree end-------------\n"); #define PRINTTREEADJ(a)\
printf("------------------after adjust Tree begin-------------\n");\
PrintBTree(a);\
printf("------------------after adjust Tree end-------------\n");
typedef int DATATYPE; typedef struct treenode
{
DATATYPE data;
struct treenode *parent;
struct treenode *lchild;
struct treenode *rchild;
unsigned int color;
}TreeNode; typedef TreeNode* RBTREE;
void PrintBTree(RBTREE* btree);
void PrintTreeNode(TreeNode* );
void PrintViewTreeNode(TreeNode* treeNode, int num);
void PrintNTab(int i);
/*
TreeNode* InitRBTree(DATATYPE oriData[], int size);
*/
RBTREE* InitRBTree(DATATYPE oriData[], int size); TreeNode *GetFixNode(RBTREE *pRBTree, DATATYPE data);
TreeNode * InitRootNode(DATATYPE data, TreeNode* pNewTreeNode);
TreeNode *InsertNode(TreeNode* pParNode, DATATYPE data);
int AdjustNode(TreeNode* pParNode, RBTREE* pRBTree);
int IsLChild(TreeNode* pSonNode);
TreeNode* Spinning(TreeNode *pCurNode,unsigned int iOp, RBTREE* pRBTree); #endif // RB_MAIN
head_file_code
process_file:rb_func.c
#include "rb_func.h" void PrintNTab(int num)
{
int i = ; while(i<num)
{
printf(" ");
i++;
}
} void PrintViewTreeNode(TreeNode* treeNode, int num)
{
num++;
char cColor;
if(RED == treeNode->color ) cColor = 'R';
if(BLACK == treeNode->color ) cColor = 'B';
printf("%d %c", treeNode->data, cColor);
if(treeNode->lchild == NULL)
{
printf("\n");
PrintNTab(num);
printf("*");
}
else
{ printf("\n");
PrintNTab(num);
PrintViewTreeNode(treeNode->lchild, num);
}
if(treeNode->rchild == NULL)
{
printf("\n");
PrintNTab(num);
printf("&"); }
else
{
printf("\n");
PrintNTab(num);
PrintViewTreeNode(treeNode->rchild, num); } } /*这个看不出来树的结构了，需要重新写打印方法。*/
void PrintTreeNode(TreeNode* treeNode)
{
if((treeNode->lchild == NULL)
&&(treeNode->rchild == NULL))
{
printf("%d\n", treeNode->data);
}
else
{
if((treeNode->lchild != NULL)
|| (treeNode->rchild != NULL))
{
printf("%d ", treeNode->data);
if(treeNode->lchild != NULL)
{
printf("--->");
PrintTreeNode(treeNode->lchild);
}
printf("%d ", treeNode->data);
if(treeNode->rchild != NULL)
{
printf("===>");
PrintTreeNode(treeNode->rchild);
}
}
}
return ;
} void PrintBTree(RBTREE* btree)
{
int num = ;
if(btree==NULL)
{
printf("empty tree.\n");
}
#if 0
printf("TreeView Rule---若一个节点有左右孩子节点,则父节点一行一列，左右孩子不同行同一列，若无做孩子，则打印的数据用*代替，如果无有孩子则打印的数据用&代替"
"另外树的层次用4个空格来体现，比如第1列代表第一层，第5列代表第二层。\n"
);
#endif
printf("***********TREE View BEGIN***********\n");
PrintViewTreeNode(*btree, num);
printf("\n");
printf("***********TREE View END ***********\n");
printf("\n");
} TreeNode * InitRootNode(DATATYPE data, TreeNode* pNewTreeNode)
{
pNewTreeNode->data = data;
pNewTreeNode->parent = NULL;
pNewTreeNode->lchild = NULL;
pNewTreeNode->rchild = NULL;
pNewTreeNode->color = B;
return pNewTreeNode;
} //查找合适的位置来插入新元素(find parent)
TreeNode *GetFixNode(RBTREE *pRBTree, DATATYPE data)
{
if((pRBTree == NULL ))
{
return NULL;
} if(((*pRBTree)->lchild == NULL)
&&((*pRBTree)->rchild == NULL))
{
printf("insert under root \n");
return *pRBTree;
}
TreeNode* pCurTreeNode = *pRBTree;
while( (pCurTreeNode->lchild != NULL)
||(pCurTreeNode->rchild !=NULL) )
{
if(data > pCurTreeNode->data)
{
//printf("insert R \n");
printf(" data=[%d] curData=[%d] insert R \n", data, pCurTreeNode->data);
if(pCurTreeNode->rchild != NULL)
{
printf("pCurTreeNode->rchild != NULL rchild[%d]\n", pCurTreeNode->rchild->data);
pCurTreeNode = pCurTreeNode->rchild; }else{ break;
}
}
else if(data < pCurTreeNode->data)
{
printf(" data=[%d] curData=[%d] insert L \n", data, pCurTreeNode->data);
if(pCurTreeNode->lchild != NULL)
{
pCurTreeNode = pCurTreeNode->lchild;
}else{
break;
}
}
else
{
printf("invaild elem here at line %d.\n", __LINE__);
return NULL;
}
}
return pCurTreeNode;
} //将一个值插入节点的L/R子树上
TreeNode *InsertNode(TreeNode* pParNode, DATATYPE data)
{
#if DEBUG
/*这里要处理相等的情况*/
if(data == pParNode->data)
{
printf("invaild data %d\n", data);
printf("invaild para here at line %d.\n", __LINE__);
return NULL;
}
#endif
TreeNode* pSonTreeNode = (TreeNode*)malloc(sizeof(TreeNode));
pSonTreeNode->data = data;
pSonTreeNode->lchild = NULL;
pSonTreeNode->rchild = NULL;
pSonTreeNode->color = RED;
pSonTreeNode->parent = pParNode;
if(data < pParNode->data)
{
pParNode->lchild = pSonTreeNode;
}
else{
pParNode->rchild = pSonTreeNode;
}
return pSonTreeNode;
}
TreeNode* Spinning(TreeNode *pCurNode,unsigned int iOp, RBTREE* pRBTree)
{
TreeNode *pLChild = NULL;
TreeNode *pRChild = NULL;
TreeNode *pParent = NULL; //TreeNode *pA = NULL;
int iIsLChild = IsLChild(pCurNode);
if(NULL == pCurNode) return NULL;
if(Left == iOp)
{
//左旋
if(NULL == pCurNode->rchild) return NULL;
pLChild = pCurNode->rchild->lchild;/*z的左孩子*/
pRChild = pCurNode->rchild;
if(- != iIsLChild){
pParent = pCurNode->parent;
}
else
{
*pRBTree = pRChild;
}
if(NULL != pLChild)
{
pLChild->parent = pCurNode;
}
pCurNode->rchild = pLChild; pRChild->lchild = pCurNode;
pCurNode->parent = pRChild; pRChild->parent = pParent;
if(- != iIsLChild)
{
if( == iIsLChild)
{
pParent->lchild = pRChild;
}
else
{
pParent->rchild = pRChild;
}
}
return pRChild;
}
else if(Right == iOp)
{
//右旋
if(NULL == pCurNode->lchild) return NULL;
pRChild = pCurNode->lchild->rchild;/*z的左孩子*/
pLChild = pCurNode->lchild;
if(- != iIsLChild){
pParent = pCurNode->parent;
}
else
{
*pRBTree = pLChild;
}
if(NULL != pRChild)
{
pRChild->parent = pCurNode;
}
pCurNode->lchild = pRChild; pLChild->rchild = pCurNode;
pCurNode->parent = pLChild; pLChild->parent = pParent;
if(- != iIsLChild)
{
if( == iIsLChild)
{
pParent->lchild = pLChild;
}
else
{
pParent->rchild = pLChild;
}
}
return pLChild; }
}
int AdjustNode(TreeNode* pCurNode, RBTREE* pRBTree)
{
if(NULL == pRBTree) goto err;
int LRFlag = ;
int CurLRFlag = ; if(BLACK == pCurNode->parent->color) return OK;
unsigned int iCase = ;
TreeNode *pParNode = pCurNode->parent;
LRFlag = IsLChild(pParNode);
CurLRFlag = IsLChild(pCurNode);
if(LRFlag)
{
/*tsb*/
if((NULL != pParNode->parent->rchild)&&
(RED == pParNode->parent->rchild->color))
{
iCase = ;
}else
{
if(CurLRFlag)
{ /*case 2:父节点是左孩子当前节点的父节点是红色,叔叔节点是黑色，当前节点是其父节点的左孩子； */
/*cur in L*/
iCase = ; }
else
{ /*case 3:当前节点的父节点是红色,叔叔节点是黑色，当前节点是其父节点的右子； */
iCase = ;
} }
/*tse*/
#if 0
if(NULL != pParNode->parent->rchild)
{
if(//(RED == pParNode->color)&&
(RED == pParNode->parent->rchild->color))
{ /*case 1:父节点是左孩子 如果当前结点的父结点是红色且祖父结点的另一个子结点（叔叔结点）是红色； */
iCase = ;
}
else if(//(RED == pParNode->color)&&
(B == pParNode->parent->rchild->color))
{
if(CurLRFlag)
{ /*case 2:父节点是左孩子当前节点的父节点是红色,叔叔节点是黑色，当前节点是其父节点的左孩子； */
/*cur in L*/
iCase = ; }
else
{ /*case 3:当前节点的父节点是红色,叔叔节点是黑色，当前节点是其父节点的右子； */
iCase = ;
}
}
}
else
{
if(CurLRFlag)
{ /*case 2:父节点是左孩子当前节点的父节点是红色,叔叔节点是黑色，当前节点是其父节点的左孩子； */
/*cur in L*/
iCase = ; }
else
{ /*case 3:当前节点的父节点是红色,叔叔节点是黑色，当前节点是其父节点的右子； */
iCase = ;
}
}
#endif
}
else
{
if(NULL != pParNode->parent->lchild)
{
if(//(RED == pParNode->color)&&
(RED == pParNode->parent->rchild->color))
{ /*case 1:父节点是R孩子 如果当前结点的父结点是红色且祖父结点的另一个子结点（叔叔结点）是红色； */
iCase = ;
}
else if(//(RED == pParNode->color)&&
(B == pParNode->parent->rchild->color))
{
if(CurLRFlag)
{ /*case 2:父节点是R孩子当前节点的父节点是红色,叔叔节点是黑色，当前节点是其父节点的左孩子； */
/*cur in L*/
iCase = ;
}
else
{ /*case 3:当前节点的父节点是红色,叔叔节点是黑色，当前节点是其父节点的右子； */
iCase = ;
}
}
}
else {
if(CurLRFlag)
{ /*case 2:父节点是R孩子当前节点的父节点是红色,叔叔节点是黑色，当前节点是其父节点的左孩子； */
/*cur in L*/
iCase = ;
}
else
{ /*case 3:当前节点的父节点是红色,叔叔节点是黑色，当前节点是其父节点的右子； */
iCase = ;
}
}
} switch (iCase) {
case :
pParNode->color = B;
pParNode->parent->rchild->color = B;
pParNode->parent->color = R; pCurNode = pParNode->parent;/*this cur is Red*/
if(pCurNode == *pRBTree)
{/*process the pCurNode is rootNode.*/
pCurNode->color = BLACK;
}else
{
AdjustNode(pCurNode, pRBTree);
}
break;
case :
pParNode->color = B;
pParNode->parent->color = R;
pCurNode = Spinning(pParNode->parent,Right, pRBTree);/*this cur is Black*/ break;
case :
pCurNode= pParNode;
pCurNode = Spinning(pCurNode,Left, pRBTree);
#if 0
pParNode = pCurNode;
pCurNode = pCurNode->lchild;
iCase = ;
#endif
pCurNode = pCurNode->lchild;
AdjustNode(pCurNode, pRBTree); break;
case :
pParNode->color = B;
pParNode->parent->lchild->color = B;
pParNode->parent->color = R;
pCurNode = pParNode->parent;
if(pCurNode == *pRBTree)
{/*process the pCurNode is rootNode.*/
pCurNode->color = BLACK;
}else
{
AdjustNode(pCurNode, pRBTree);
}
break;
case : pCurNode= pParNode;
pCurNode =Spinning(pCurNode,Right,pRBTree);
#if 0
pParNode = pCurNode;
pCurNode = pCurNode->rchild;
iCase = ; #endif
pCurNode = pCurNode->rchild;
AdjustNode(pCurNode, pRBTree); break;
case :
pParNode->color = B;
pParNode->parent->color = R;
pCurNode = Spinning(pParNode->parent,Left, pRBTree); break;
default:
goto err;
break;
}
return OK; err:
printf("in para err.\n");
return ERR; }
/*1---------->is*/
int IsLChild(TreeNode* pSonNode)
{
if(pSonNode->parent ==NULL)return -;
return ((pSonNode->parent->lchild == pSonNode)?:);
} /* 这个返回值不好，改掉哈哈
* TreeNode* InitRBTree(DATATYPE oriData[], int size)
*/
RBTREE* InitRBTree(DATATYPE oriData[], int size)
{
RBTREE* pRBTree = NULL;
pRBTree = (RBTREE*)malloc(sizeof(RBTREE));
*pRBTree = (TreeNode*)malloc(sizeof(TreeNode));
int pos = size;
int iRet = ;
InitRootNode(oriData[], *pRBTree);
TreeNode *pParentPosNode = NULL;
TreeNode *pCurNode = NULL; while(pos>)
{
#if DEBUG
printf("********begin one*************\n");
printf("pos = [%d] index =[%d] insert_data[%d]\n", pos, size-pos+, oriData[size-pos+]);
#endif
pParentPosNode = GetFixNode(pRBTree, oriData[size-pos+]);
#if DEBUG
printf("Parent = [%d] Insert data=[%d] \n", pParentPosNode->data, oriData[size-pos+] );
#endif
pCurNode = InsertNode(pParentPosNode, oriData[size-pos+]); iRet = AdjustNode(pCurNode, pRBTree);
PrintBTree(pRBTree);
pos--;
#if DEBUG
printf("********end one*************\n\n");
#endif } printf("********pRBTree data %d*************\n\n", (*pRBTree)->data); return pRBTree; }
process_code
main_file:main.c
#include <stdio.h>
#include "rb_func.h" int testcase_1()
{
/*
* int iArr[]= {12,1,9,2,0,11,7};
*/
int iArr[]= {,,,,,,,,,,,,,,,,,,,}; #if 0
/*这里写的不好，initRBTree原先返回的是TreeNode* ,现在改为指向返回RBTREE*的指针*/
RBTREE *avlTree = NULL;
TreeNode *rootNode = NULL;
rootNode= InitRBTree(iArr, sizeof(iArr)/sizeof(iArr[]));
avlTree = (RBTREE*)malloc(sizeof(TreeNode*));
*avlTree = (TreeNode*)malloc(sizeof(TreeNode));
*avlTree = rootNode;
#endif
RBTREE *pRBTree = InitRBTree(iArr, sizeof(iArr)/sizeof(iArr[]));
PRINTTREEINIT(pRBTree);
return ;
}
int main(void)
{
testcase_1();
return ;
}
main_code
运行的demo数据（数组）是从一个网站上copy的，这里贴上我的运行结果：
********begin one*************
pos = [] index =[] insert_data[]
insert under root
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
R
*
&
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert L
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
R
*
&
R
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert L
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
B
*
R
*
&
B
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert L
data=[] curData=[] insert L
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
B
R
*
&
R
*
&
B
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
B
R
*
&
R
*
&
B
R
*
&
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert L
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
R
B
*
&
B
*
R
*
&
B
R
*
&
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
R
B
*
&
B
*
R
*
&
B
R
*
&
R
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert L
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
R
B
*
&
B
R
*
&
R
*
&
B
R
*
&
R
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
R
B
*
&
B
R
*
&
R
*
&
R
B
*
&
B
R
*
&
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert L
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
R
B
*
&
B
R
*
&
R
*
&
R
B
*
&
B
R
*
&
R
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert L
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
B
B
*
&
R
B
*
&
B
R
*
&
&
B
B
*
&
B
R
*
&
R
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert L
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
B
B
*
&
R
B
*
&
B
R
*
&
&
B
B
*
&
R
B
R
*
&
&
B
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert L
data=[] curData=[] insert L
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
B
B
*
&
R
B
*
&
B
R
*
&
&
B
B
*
&
R
B
R
*
&
R
*
&
B
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert L
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
B
B
*
&
R
B
*
&
B
R
*
&
&
B
B
R
*
&
&
R
B
R
*
&
R
*
&
B
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert L
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
B
B
*
&
R
B
*
&
B
R
*
&
&
R
B
R
*
&
&
B
R
B
*
&
B
*
R
*
&
B
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert L
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert L
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
B
B
*
&
R
B
*
&
B
R
*
&
R
*
&
R
B
R
*
&
&
B
R
B
*
&
B
*
R
*
&
B
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert L
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert L
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
B
B
*
&
R
B
*
R
*
&
B
R
*
&
R
*
&
R
B
R
*
&
&
B
R
B
*
&
B
*
R
*
&
B
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert L
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
R
B
*
&
B
B
*
R
*
&
R
B
*
&
B
*
R
*
&
R
B
R
*
&
&
B
R
B
*
&
B
*
R
*
&
B
*
&
***********TREE View END *********** ********end one************* ********begin one*************
pos = [] index =[] insert_data[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert L
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
data=[] curData=[] insert R
pCurTreeNode->rchild != NULL rchild[]
Parent = [] Insert data=[]
***********TREE View BEGIN***********
B
R
B
*
&
B
B
*
R
*
&
R
B
*
&
B
*
R
*
&
R
B
R
*
&
&
B
R
B
*
&
B
R
*
&
R
*
&
B
*
&
***********TREE View END *********** ********end one************* ********pRBTree data ************* ------------------init Tree begin-------------
***********TREE View BEGIN***********
B
R
B
*
&
B
B
*
R
*
&
R
B
*
&
B
*
R
*
&
R
B
R
*
&
&
B
R
B
*
&
B
R
*
&
R
*
&
B
*
&
***********TREE View END *********** ------------------init Tree end-------------
run_result
删除节点估计要等光棍节后才能写。o(^▽^)o
红黑树(RBTREE)之上-------构造红黑树的更多相关文章
- 平衡搜索树--红黑树 RBTree
红黑树是一棵二叉搜索树,它在每个节点上增加了一个存储位来表示节点的颜色,可以是Red或Black. 通过对任何一条从根到叶子节点简单路径上的颜色来约束树的高度,红黑树保证最长路径不超过最短路径的两倍, ...
- 高级搜索树-红黑树(RBTree)代码实现
代码实现 代码参考了<数据结构(c++语言版)>--清华大学邓俊辉 "RBTree.h" #pragma once //#include"pch.h" ...
- 高级搜索树-红黑树(RBTree)解析
目录 红黑树的定义 节点与树的定义 旋转操作 插入操作 情况1:p的兄弟u为黑色 情况2: p的兄弟u为红色 插入操作性能分析 代码实现 删除操作 情况1:x的接替者succ为红色 情况2:x的接替者 ...
- java——红黑树 RBTree
对于完全随机的数据,普通的二分搜索树就很好用,只是在极端情况下会退化成链表. 对于查询较多的情况,avl树很好用. 红黑树牺牲了平衡性,但是它的统计性能更优(综合增删改查所有的操作). 红黑树java ...
- 红黑树RBTree
#pragma onceenum colour //子节点的颜色{ RED, BLANK,};template<class K,class V>struct RBTree ...
- HaspMap源码分析（JDK 1.8）
底层结构分析 上面这两张图分别画出了JDK 1.7.1.8底层数据结构,在JDK 1.7.1.8中都使用 了散列算法,但是在JDK 1.8中引入了红黑树,在链表的长度大于等于8并且hash桶的长度大于 ...
- RBTree 红黑树
红黑树 一.红黑树概述 红黑树不仅是一个二叉搜索树,并且满足以下规则: 1>每个节点不是红的就是黑的, 2>根结点为黑色, 3>如果节点为红色,其子节点必须为黑色, 4>任一节 ...
- 红黑树(二)之 C语言的实现
概要 红黑树在日常的使用中比较常用,例如Java的TreeMap和TreeSet,C++的STL,以及Linux内核中都有用到.之前写过一篇文章专门介绍红黑树的理论知识,本文将给出红黑数的C语言的实现 ...
- 红黑树(四)之 C++的实现
概要 前面分别介绍红黑树的理论知识和红黑树的C语言实现.本章是红黑树的C++实现,若读者对红黑树的理论知识不熟悉,建立先学习红黑树的理论知识,再来学习本章. 目录1. 红黑树的介绍2. 红黑树的C++ ...
随机推荐
- 洛谷P2915 [USACO08NOV]奶牛混合起来Mixed Up Cows 状压动归
考场上空间开大了一倍就爆0了QAQ- Code: #include<cstdio> #include<algorithm> #include<cmath> usin ...
- 树莓派搭建 Google TV
出处:http://my.oschina.net/funnky/blog/142067 树莓派搭建 Google TV 目录:[ - ] Google TV是啥玩意 ? 搭建我们自己的Google T ...
- 作用域与this
面向对象 一.单例模式 1.1 对象数据类型的作用: 把描述一个对象的属性和方法放在一个单独的空间,与其他的对象分割开,即时出现属性名相同的情况,也不会产生冲突 var name="xiao ...
- [LUOGU]3919 【模板】可持久化数组
用可持久化线段树维护可持久化数组.可持久化线段树见之前发的主席树模板 #include <iostream> #include <cstdio> #include <cs ...
- tensorflow的tf.train.Saver()模型保存与恢复
将训练好的模型参数保存起来,以便以后进行验证或测试.tf里面提供模型保存的是tf.train.Saver()模块. 模型保存,先要创建一个Saver对象:如 saver=tf.train.Saver( ...
- 大数据相关文档&Api下载
IT相关文档&Api下载(不断更新中) 下载地址:https://download.csdn.net/user/qq_42797237/uploads 如有没有你需要的API,可和我留言,留下 ...
- 2019-03-25 Python Pandas 基本操作
新建表 data1 = { "name": ["Tom", "Bob", "Mary", "James&quo ...
- unity 获取UGUI中的Text字的坐标
using System.Collections; using UnityEngine; using UnityEngine.UI; public class TextMoveHelper : Mon ...
- 监控iis计数器
- 2015 Multi-University Training Contest 7 hdu 5375 Gray code
Gray code Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)Total S ...