该怎么说呢,现在写代码的速度还是很快的,很高兴,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)之上-------构造红黑树的更多相关文章

  1. 平衡搜索树--红黑树 RBTree

    红黑树是一棵二叉搜索树,它在每个节点上增加了一个存储位来表示节点的颜色,可以是Red或Black. 通过对任何一条从根到叶子节点简单路径上的颜色来约束树的高度,红黑树保证最长路径不超过最短路径的两倍, ...

  2. 高级搜索树-红黑树(RBTree)代码实现

    代码实现 代码参考了<数据结构(c++语言版)>--清华大学邓俊辉 "RBTree.h" #pragma once //#include"pch.h" ...

  3. 高级搜索树-红黑树(RBTree)解析

    目录 红黑树的定义 节点与树的定义 旋转操作 插入操作 情况1:p的兄弟u为黑色 情况2: p的兄弟u为红色 插入操作性能分析 代码实现 删除操作 情况1:x的接替者succ为红色 情况2:x的接替者 ...

  4. java——红黑树 RBTree

    对于完全随机的数据,普通的二分搜索树就很好用,只是在极端情况下会退化成链表. 对于查询较多的情况,avl树很好用. 红黑树牺牲了平衡性,但是它的统计性能更优(综合增删改查所有的操作). 红黑树java ...

  5. 红黑树RBTree

    #pragma onceenum colour    //子节点的颜色{    RED,    BLANK,};template<class K,class V>struct RBTree ...

  6. HaspMap源码分析(JDK 1.8)

    底层结构分析 上面这两张图分别画出了JDK 1.7.1.8底层数据结构,在JDK 1.7.1.8中都使用 了散列算法,但是在JDK 1.8中引入了红黑树,在链表的长度大于等于8并且hash桶的长度大于 ...

  7. RBTree 红黑树

    红黑树 一.红黑树概述 红黑树不仅是一个二叉搜索树,并且满足以下规则: 1>每个节点不是红的就是黑的, 2>根结点为黑色, 3>如果节点为红色,其子节点必须为黑色, 4>任一节 ...

  8. 红黑树(二)之 C语言的实现

    概要 红黑树在日常的使用中比较常用,例如Java的TreeMap和TreeSet,C++的STL,以及Linux内核中都有用到.之前写过一篇文章专门介绍红黑树的理论知识,本文将给出红黑数的C语言的实现 ...

  9. 红黑树(四)之 C++的实现

    概要 前面分别介绍红黑树的理论知识和红黑树的C语言实现.本章是红黑树的C++实现,若读者对红黑树的理论知识不熟悉,建立先学习红黑树的理论知识,再来学习本章. 目录1. 红黑树的介绍2. 红黑树的C++ ...

随机推荐

  1. 中国人自己的技术!百度开源自研底层区块链XuperChain

    中国人自己的技术!百度开源自研底层区块链XuperChain 近年来,我国各行各业迅猛发展,但不少尖端行业和产品仍然依赖进口,关键领域受制于人,火热的区块链领域也是如此. 在中国国际大数据产业博览会现 ...

  2. Java中使用MD5加密的简单实现

    import java.math.BigInteger; import java.security.MessageDigest; import java.security.NoSuchAlgorith ...

  3. [转] hadoop MapReduce实例解析-非常不错,讲解清晰

    来源:http://blog.csdn.net/liuxiaochen123/article/details/8786715?utm_source=tuicool 2013-04-11 10:15 4 ...

  4. css——导航栏

    导航栏一般用无序列表制作 但出来的导航栏有黑点,还有一些边距 去除黑点我们可以用:list-style-type: none;/*去掉ul前面的点*/ 因为有些标签之间会有默认的边距,所以可以先将边踞 ...

  5. failed to push some refs to 'git@github.com:RocsSun/mytest.git

    Git推送到GitHub仓库失败 使用Git将文件推送至GitHub的远程仓库时,报错failed to push some refs to 'git@github.com:RocsSun/mytes ...

  6. PHP的迭代器和生成器

    一.迭代器 分析:想一下,如果把集合对象和对集合对象的操作放在一起,当我们想换一种方式遍历集合对象中元素时,就需要修改集合对象了,违背"单一职责原则",而迭代器模式将数据结构和数据 ...

  7. W10如何开启LinuxBash及安装Ubuntu

    W10如何开启LinuxBash的功能 1)开启开发人员模式 2)启动部分windows功能 完成后重启系统 然后在cmd中输入bash按命令操作即可使用bash命令 3)下载安装ubuntu lxr ...

  8. Mysql怎么样避免全表扫描,sql查询优化

    对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引: 尝试下面的技巧以避免优化器错选了表扫描: 使用ANALYZE TABLE tbl_name为扫 ...

  9. Android实战简易教程-第十三枪(五大布局研究)

    我们知道Android系统应用程序通常是由多个Activity组成,而这些Activity以视图的形式展如今我们面前, 视图都是由一个一个的组件构成的. 组件就是我们常见的Button.TextEdi ...

  10. 闭包(closure)与协程共用时要注意的事情

    闭包是一种能够让你用非常舒服的方式来编程的小技巧,Go也支持闭包. 假设从来没有接触过闭包,想在一開始就弄懂什么是闭包(closure)是非常困难的,就像递归一样,直到你真正写过.用过它,你才干真正的 ...