明论  

 

   之前由于考虑到使用Page的内存和磁盘互换的机制实现了B-tree做为数据库的键值索引,在真实的生产环境下2000万以上的数据建立索引会使到B-tree层数增多,效率明显下降,在运算工程中使用AIX大型机都用了数天才将2000多万的数据生成出来,效果非常不理想。
   全新的框架采用了纯内存的红黑树作为数据的索引,效果很好,性能测试中,用thinkpad 201i 电脑建立1000万的红黑树只用了3分钟,消耗内存270M这在电信项目的生产环境是完全可以接受的。
   该代码使用内存池和红黑树的技术,参考主要文献包括:
   http://zh.wikipedia.org/zh/%E7%BA%A2%E9%BB%91%E6%A0%91 维基百科
   IBM文章,http://www.ibm.com/developerworks/cn/linux/l-cn-ppp/index6.html
   当然网上许多人的实现也给了我很好的启示,恕在下不能一一列出。
   也许你会说,不就实现了STL MAP的功能吗?可以这么说,因为内存中建立数据结构,红黑树是最优的方案,我只能使用这样的---像map一样的东西。
   以下是大致实现代码的思路,使用内存池来存放两类数据,一类是存放红黑树节点的内存池,一类是存放键值节点的内存池。

 

   实例代码并不是用于项目中的实现,而是呈现内存索引的DEMO,其中delete的实现我没有实现内存释放,读者可以自己添加,相信它是网上能找到的最好,最清晰的红黑树能直接编译并稳定使用的代码,网上文章的代码都有这样那样的问题,最后还是根据理论自己实现了。

   很多朋友对于内存数据库开发Email给我不能一一回复很抱歉,希望代码对各位有帮助。

 

  另外内存池的代码请参考我的另一篇文章,内存池的实现 内存池完整实现代码及一些思考

 

 

 


//该代码参照维基百科提供http://zh.wikipedia.org/zh/%E7%BA%A2%E9%BB%91%E6%A0%91 提供理论基础,2010-2011年由 konyellin Email: konyel@163.com进行整理修改



#include 
<string>
#include 
"MemoryPool.h"

#define    RB_INT        0
#define    RB_FLOAR    1
#define    RB_CHAR     2



struct rb_node
{
    unsigned 
short  color;
#define    RB_RED        0
#define    RB_BLACK    1
    
struct rb_node* right;
    
struct rb_node* left;
    
struct rb_node* parent;
    
void* memoryblock;
    
void* key;
};

class rb_tree{
public:
    rb_tree(unsigned 
short type);
   
//search
   rb_node* rb_search(void* key);
   
void  rb_insert(void* key);
   rb_node
*  rb_delete(void* key);
   
//debug
   void print_tree(struct rb_node* root,int nLayer);


   
struct rb_node* root;
   
private:
   MemoryPool
* pool;
   unsigned 
short datetype;
  
   
//insert case
   void __insert_case1(struct rb_node* n);
   
void __insert_case2(struct rb_node* n);
   
void __insert_case3(struct rb_node* n);
   
void __insert_case4(struct rb_node* n);
   
void __insert_case5(struct rb_node* n);

   
//delete case
   void __delete_case1(struct rb_node* n);
   
void __delete_case2(struct rb_node* n);
   
void __delete_case3(struct rb_node* n);
   
void __delete_case4(struct rb_node* n);
   
void __delete_case5(struct rb_node* n);
   
void __delete_case6(struct rb_node* n);

   
//rotate
   void __rotate_left(struct rb_node *node);
   
void __rotate_right(struct rb_node *node);
   
void __replace_node(struct rb_node* node ,struct rb_node*  child);
   
bool __is_leaf(struct rb_node* n);
   
   
//查户口
   rb_node* __grandparent(struct rb_node* n);
   rb_node
* __uncle(struct rb_node* n);
   rb_node
* __sibling(struct rb_node* n);

   
//比较键值查询
   int __rb_cmpkey(void* key1,void* key2);

   rb_node
* __createnode(void* key);
};


#include "Rbtree.h"


rb_tree::rb_tree(unsigned 
short type):datetype(type){
   root
=NULL;
   pool
=new MemoryPool(sizeof(rb_node));
}

/*----------------------------------------------------------- 
|   node           right 
|   / \    ==>     / \ 
|   a  right     node  y 
|       / \       / \     
|       b  y     a   b    //左旋 
-----------------------------------------------------------
*/  
rb_node
* rb_tree::rb_search(void* key){
  
struct rb_node* fnode=root;
  
bool iskey=true;int ret=0;
  
while(ret=__rb_cmpkey(fnode->key,key)){
      
if(__is_leaf(fnode)){
         iskey
=0;
         
break;
      }
      
if(ret>0)
            fnode
=fnode->right;
      
else
            fnode
=fnode->left;
            
  }
  
if(iskey)
    
return fnode;
  
else
    
return NULL;
}



void rb_tree::__rotate_left(struct rb_node *node){
  rb_node
* right = node->right;                   //指定指针指向 right<--node->right  
    if ((node->right = right->left))     
        right
->left->parent = node;                 //好比上面的注释图,node成为b的父母  
    right->left = node;                             //node成为right的左孩子   
    if ((right->parent = node->parent)) {           //如果node根节点为空,node本身为根节点  
        if (node == node->parent->right)            //如果node为右节点
            node->parent->right = right;  
        
else  
            node
->parent->left = right;  
    }  
    
else  
        root 
= right;   
    node
->parent = right;                           //right成为node的父母   
}

void rb_tree::__rotate_right(struct rb_node *node){
    rb_node
* left = node->left;  
    
if ((node->left = left->right))
        left
->right->parent = node;  
    left
->right = node;  
    
if ((left->parent = node->parent)){  
        
if (node == node->parent->right)  
            node
->parent->right = left;  
        
else  
            node
->parent->left = left;  
    }  
    
else  
        root 
= left;  
    node
->parent = left; 
}

rb_node
* rb_tree::__grandparent(struct rb_node* n) {
   
if(n->parent==NULL)
       
return NULL;
   
return n->parent->parent;
}
rb_node
* rb_tree::__uncle(struct rb_node* n) {
    
if(__grandparent(n)==NULL)
        
return NULL;
    
if (n->parent == __grandparent(n)->left)
    
return __grandparent(n)->right;
    
else
    
return __grandparent(n)->left;
}

rb_node
* rb_tree::__sibling(struct rb_node* n){
    
if (n == n->parent->left)
    
return n->parent->right;
    
else
    
return n->parent->left;
}

void rb_tree::__replace_node(struct rb_node* n, struct rb_node* child){
    child
->memoryblock=n->memoryblock;
    child
->key=n->key;
}
rb_node
* rb_tree::__createnode(void* key){
       
struct rb_node* node=(rb_node*)pool->Alloc();
       memset(node,
0x00,sizeof(rb_node));
       node
->key=key;
       node
->color=RB_RED;
       
return node;
}

bool rb_tree::__is_leaf(struct rb_node* n){
    
if(n->left==NULL&&n->right==NULL)
        
return true;
    
return false;
}
int rb_tree::__rb_cmpkey(void* key1,void* key2){
    
switch(datetype){
       
case RB_INT:{
            
if(*((int*)key1)<*((int*)key2))
              
return -1;
            
else if(*((int*)key1)>*((int*)key2))
              
return 1;
            
else 
              
return 0;
            
break;
            }
       
case RB_FLOAR:{
            
if(*((float*)key1)<*((float*)key2))
                  
return -1;
                
else if(*((float*)key1)>*((float*)key2))
                  
return 1;
                
else 
                  
return 0;
                
break;
            }
       
case RB_CHAR:{
            
char* s1=(char*)key1;char* s2=(char*)key1;
            
return strcmp(s1,s2);
            
break;
            }
    }
    
return 0;
}
//按树状打印的二叉树
void rb_tree::print_tree(struct rb_node* root,int nLayer)
{
    
if(root==NULL)
        
return ;
    print_tree(root
->right,nLayer+1);
    
for(int i=0;i<nLayer;i++){
       printf(
"   ");
    }
    printf(
"%d-%d\n",*(int*)root->key,root->color);
    print_tree(root
->left,nLayer+1);
}

 

#include "Rbtree.h"



//如果插入为根节点
void rb_tree::__insert_case1(struct rb_node* n){
    
if (n->parent == NULL){
        n
->color = RB_BLACK;
    }
    
else
    __insert_case2(n);
}

void rb_tree::__insert_case2(struct rb_node* n){
   
if (!(n->parent->color == RB_BLACK))
   __insert_case3(n);
}
//叔叔为红色节点的情况
void rb_tree::__insert_case3(struct rb_node* n){
    
if (__uncle(n) != NULL && __uncle(n)->color == RB_RED) {
        n
->parent->color = RB_BLACK;
        __uncle(n)
->color = RB_BLACK;
        __grandparent(n)
->color = RB_RED;
        __insert_case1(__grandparent(n));
    }
    
else{
        __insert_case4(n);
    }
}

void rb_tree::__insert_case4(struct rb_node* n) {
    
if (n == n->parent->right && n->parent == __grandparent(n)->left) {
        __rotate_left(n
->parent);
        n 
= n->left;
    } 
else if (n == n->parent->left && n->parent == __grandparent(n)->right) {
        __rotate_right(n
->parent);
        n 
= n->right;
    }
    __insert_case5(n);
}

void rb_tree::__insert_case5(struct rb_node* n) {
    n
->parent->color = RB_BLACK;
    __grandparent(n)
->color = RB_RED;
    
if (n == n->parent->left && n->parent == __grandparent(n)->left) {
        __rotate_right(__grandparent(n));
    } 
else {
        __rotate_left(__grandparent(n));
   }
}


void rb_tree::rb_insert(void* key){
    
struct rb_node* addnode = __createnode(key);
    
//为空树的情况,创建根节点
    if(root==NULL){
         root
=addnode;
         
//根节点染黑
         root->color=RB_BLACK;
         
return;
    }
    
struct rb_node* fnode=root;
    
int ret=0;
    
while(ret=__rb_cmpkey(fnode->key,key)){
        
if(__is_leaf(fnode)){
            
if(ret>0){
                fnode
->right=addnode;
                addnode
->parent=fnode;
            }
            
else{
                fnode
->left=addnode;
                addnode
->parent=fnode;
            }
            
break;
        }
        
if(ret>0)
            fnode
=fnode->right;
        
else
            fnode
=fnode->left;
    }
    __insert_case1(addnode);
}

 

 

//Rbtree_Delete.cpp by konyel
#include "Rbtree.h"



void rb_tree::__delete_case1(struct rb_node* n){
    
if (n->parent != NULL)
    __delete_case2(n);
}

void rb_tree::__delete_case2(struct rb_node* n)
{
    
struct rb_node* s = __sibling(n);
    
if (s->color == RB_RED) {
        n
->parent->color = RB_RED;
        s
->color = RB_BLACK;
        
if (n == n->parent->left)
        __rotate_left(n
->parent);
        
else
        __rotate_right(n
->parent);
    }
    __delete_case3(n);
}

void rb_tree::__delete_case3(struct rb_node* n){
    
struct rb_node* s = __sibling(n);
    
if ((n->parent->color == RB_BLACK) &&
    (s
->color == RB_BLACK) &&
    (s
->left==NULL||s->left->color == RB_BLACK) &&
    (s
->right==NULL||s->right->color == RB_BLACK)) {
        s
->color = RB_RED;
        __delete_case1(n
->parent);
    } 
else
    __delete_case4(n);
}

void rb_tree::__delete_case4(struct rb_node* n){
    
struct rb_node* s = __sibling(n);
    
if ((n->parent->color == RB_RED) &&
    (s
->color == RB_BLACK) &&
    (s
->left==NULL||s->left->color == RB_BLACK) &&
    (s
->right==NULL||s->right->color == RB_BLACK)) {
            s
->color = RB_RED;
            n
->parent->color = RB_BLACK;
    } 
else
    __delete_case5(n);
}

void rb_tree::__delete_case5(struct rb_node* n){
    
struct rb_node* s = __sibling(n);
    
if (s->color == RB_BLACK) {/* this if statement is trivial,
        due to Case 2 (even though Case two changed the sibling to a sibling's child,
        the sibling's child can't be red, since no red parent can have a red child). 
*/
        
// the following statements just force the red to be on the left of the left of the parent,
        
// or right of the right, so case six will rotate correctly.
        if ((n == n->parent->left) &&
        (s
->right->color == RB_BLACK) &&
        (s
->left->color == RB_RED)) { // this last test is trivial too due to cases 2-4.
            s->color = RB_RED;
            s
->left->color = RB_BLACK;
            __rotate_right(s);
            } 
else if ((n == n->parent->right) &&
            (s
->left->color == RB_BLACK) &&
            (s
->right->color == RB_RED)) {// this last test is trivial too due to cases 2-4.
                s->color = RB_RED;
                s
->right->color = RB_BLACK;
                __rotate_left(s);
            }
    }
    __delete_case6(n);
}

void rb_tree::__delete_case6(struct rb_node* n){
    
struct rb_node* s = __sibling(n);
    s
->color = n->parent->color;
    n
->parent->color = RB_BLACK;
    
if (n == n->parent->left) {
        s
->right->color = RB_BLACK;
        __rotate_left(n
->parent);
    } 
else {
        s
->left->color = RB_BLACK;
        __rotate_right(n
->parent);
    }
}
rb_node
* rb_tree::rb_delete(void* key){
    
//两边都不是叶子节点
    struct rb_node* min_node;
    
struct rb_node* fnode=root;
    
int ret=0;
    
while(ret=__rb_cmpkey(fnode->key,key)){
         
if(__is_leaf(fnode)){
           
return NULL;
         }
         
if(ret>0)
             fnode
=fnode->right;
         
else
             fnode
=fnode->left;
    }
    
if(fnode->right!=NULL){
          min_node
=fnode->right;
          
while(min_node->left!=NULL)
              min_node
=min_node->left;
    }
    
else if(fnode->left!=NULL){
        min_node
=fnode->left;
        
while(min_node->right!=NULL)
              min_node
=min_node->right;
    }
    
else{
        min_node
=fnode;
    }
    
    __replace_node(fnode, min_node);
    
//用非叶子节点替换要删除的节点
    if (fnode->color == RB_BLACK) {
        
if (min_node->color == RB_RED)
            min_node
->color = RB_BLACK;
        
else
            __delete_case1(min_node);
    }
    
if(!__is_leaf(min_node)){
       
return NULL;
    }
    
if(min_node==root)
        root
==NULL;
    
else if(min_node->parent->right==min_node)
        min_node
->parent->right=NULL;
    
else
        min_node
->parent->left=NULL;
    pool
->Free(min_node);
    
return NULL;
}

 


 

posted on 2011-06-23 20:13  konyel  阅读(4304)  评论(15编辑  收藏  举报