经过自动压力测试的红黑树(删除功能完备)

最新推荐文章于 2023-10-17 19:23:29 发布
最新推荐文章于 2023-10-17 19:23:29 发布
阅读量678 收藏
点赞数
分类专栏： 综合 文章标签： 测试 insert delete struct include null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenbingchenbing/article/details/7020538
版权
 

#include  <stdio.h>
#include  <stdlib.h>

#define   COUNT   10000
#define   RAND    (4*COUNT)

int  error_label=0;


#pragma  pack(1)
typedef   enum  _color
  {
    RED,
    BLACK
  }color;

typedef   struct  _data
{
  int  value;
}data;
typedef  struct  _redblack
{
  color    m_color;
  int   m_data;
  struct  _redblack  *parent;
  struct  _redblack  *left;
  struct  _redblack  *right;
}redblack;
typedef  struct  _wrapredblack
{
  struct  _wrapredblack  *next;
  redblack  real;
}wrapredblack;
typedef  struct  _wrapdata
{
  redblack  *root;
  int  size;
}wrapdata;
#pragma  pack()


wrapredblack  global[2*RAND];
wrapredblack  *head;
wrapredblack  *tail;
wrapdata  *global_node;


void  init( )
{
  int  i,j;
  for(i=0;i<RAND-1;i++)
    {
      global[i].next=&global[i+1];
    }
  head=&global[0];
  tail=&global[RAND-1];
}

redblack  *mycalloc ( )
{
  redblack  *temp=&head->real;
  head=head->next;
  return  temp;
  //  return (redblack *) calloc (1 ,sizeof (redblack));
}
int checkvalid ( redblack *del,redblack *root)
{
  if(!root)
    {
      return  0;
    }
  else
    {
      if(checkvalid(del,root->left))
 {
   return  1;
 }
      if(checkvalid  (del,root->right))
 {
   return    1;
 }
      if (root==del)
 {
   return  1;
 }
      else
 {
   return  0;
 }
    }
}
void  myfree (redblack  *node)
{
  wrapredblack  *temp = (wrapredblack *)( (int)node-4);
  temp->next=0;
  node->left=node->right=node->parent=0;
  tail->next=temp;
  tail=temp;

  if(checkvalid (node,global_node->root))
    {
      exit(0);
    }


   
  return ;
}

int  compare ( int data   ,redblack  *right)
{
  if(data >  right->m_data)
    {
      return  1;
    }
  else    if(data ==  right->m_data)
    {
      return  -1;
    }
  else
    {
      return  0;
    }
}

redblack  * newstruct ( int value)
{
  redblack  *newnode;
  newnode=(redblack *)mycalloc ();
  newnode->m_color=RED;
  newnode->m_data =value;
  return  newnode;
}

void  rotate_right ( redblack * left ,redblack  *right )
{

  right->left=left->right;
  if(left->right)
    {
      left->right->parent=right;
    }

  left->right=right;
  left->parent=right->parent;
  if(right->parent)
    {
      if(right->parent->left==right)
 {
   right->parent->left=left;
 }
      else
 {
   right->parent->right=left;
 }
    }
  right->parent=left;

}

void  rotate_left ( redblack * left ,redblack  *right )
{
  left->right=right->left;
  if (right->left)
    {
      right->left->parent=left;
    }

  right->left=left;
  right->parent=left->parent;
  if(left->parent)
    {
      if(left->parent->right==left)
 {
   left->parent->right=right;
 }
      else
 {
   left->parent->left=right;
 }
    }
  left->parent=right;
}

int   mid_print (redblack  *root,int level)
{
  int  left,right;
  if(level>40)
    {
      printf("error\n");
      error_label=1;
      return 100000 ;
    }
  if (!root)
    {
      return  0;
    }
  else
    {
      left=mid_print (root ->left,level+1);
      printf("{address=%x color=%s,level=%d ,value=%d}   ",root ,root->m_color==RED?"red":"black",level ,root->m_data);
      //   printf(" %d   ",root->m_data->value);
      right= mid_print  (root  ->right,level+1);
      return  left+right+1;
    }
}

int   check (redblack  *root)
{
  int  left,right;
  if (!root)
    {
      return  0;
    }
  else
    {
      left=check (root ->left);
      right= check  (root  ->right);
      if(left||right)
 {
   return  1;
 }
      if(  root->left  && ( root->left->m_data >  root->m_data ||  root->left->parent!=root)  )
 {
   return  1;
 }
      if(  root->right  && ( root->right->m_data <  root->m_data  || root->right->parent!=root))
 {
   return  1;
 }
      else
 {
   return  0;
 }

    }
}


void   left_print (redblack  *root)
{
  if (!root)
    {
      return;
    }
  else
    {
      printf("%d   ",root->m_data);
      left_print (root ->left);
      left_print  (root  ->right);
    }
}


void   right_print (redblack  *root)
{
  if (!root)
    {
      return;
    }
  else
    {
      right_print (root ->left);
      right_print  (root  ->right);
      printf("%d   ",root->m_data);
    }
}

int  depth(redblack  *root)
{
  int  left,right;
  if (!root)
    {
      return 0;
    }
  else
    {
      left=depth(root->left);
      right=depth(root->right);
      return        left>right ? ( left+1):(right+1);

    }
}
void  insert_fixup (wrapdata  *node , redblack *newnode)
{

  redblack *curnode;
  redblack  *parent;
  redblack  *grandparent;
  redblack *tmp;
  curnode=newnode;
  parent=curnode->parent;
  while(  curnode->m_color==RED  &&   parent ->m_color==RED)
    {
      grandparent=parent->parent;
      if ( curnode == parent->left)
 {
   if (  parent == grandparent->left)
     {
       curnode->m_color=BLACK;
       rotate_right ( parent , grandparent);

       curnode=parent;
              parent=curnode->parent;
              if(!parent )
  {
    node->root=curnode;
    break;
  }
     }
   else
     {
       //       printf("nothing");
       rotate_right (curnode,  parent );
       tmp=parent;
       parent=curnode;
       curnode=tmp;

       curnode->m_color=BLACK;
       rotate_left (grandparent ,parent );

       curnode=parent;
              parent=curnode->parent;
              if(!parent )
  {
    node->root=curnode;
    break;
  }
     }
 }
      else
 {
   if (  parent== grandparent->right)
     {
       curnode->m_color=BLACK;
       rotate_left (grandparent,parent );

       curnode=parent;
              parent=curnode->parent;
              if(!parent )
  {
    node->root=curnode;
    break;
  }

     }
   else
     {
       //       printf("nothing");
       rotate_left (  parent ,curnode);
       tmp=parent;
       parent=curnode;
       curnode=tmp;

       curnode->m_color=BLACK;
       rotate_right (parent,grandparent );

       curnode=parent;
              parent=curnode->parent;
              if(!parent )
  {
    node->root=curnode;
    break;
  }
     }
 }
    }
}
redblack  * find(redblack *root ,int  data)
{
  if (! root)
    {
      return  NULL;
    }
  else
    {
      if ( data ==  root->m_data)
 {
   return  root;
 }
      else      if  (  data >  root->m_data)
 {
   return  find (root ->right ,data);
 }
      else
 {
   return  find (root->left ,data );
 }
    }
}

redblack  * next (redblack  * mostleft)
{
  //   if
  if(! mostleft->left)
    {
      return  mostleft;
    }
  else
    {
      return   next ( mostleft->left);
    }
}

void  delete_fixup (wrapdata *node,  redblack *curnode ,int mode)
{
  redblack  *parent;
  redblack  *uncle;
  redblack  *uncle_left;
  redblack  *uncle_right;

  while(1)
    {
      if (curnode->m_color==RED)
 {
   curnode->m_color=BLACK;
   parent=curnode->parent;
   if(!parent)
     {
       node->root=curnode;
     }
   return ;
 }
      else
 {
   parent=curnode->parent;
   if(!parent)
     {
       node->root=curnode;
       return ;
     }
   if(0==mode)
     {

       uncle=parent->right;
       if(!uncle)
  {
    return ;
  }

       if (uncle->m_color== RED)
  {
    uncle->m_color=BLACK;
    parent->m_color=RED;
    rotate_left (parent,uncle );
    if (!uncle->parent)
      {
        node->root=uncle;
      }

  }
       else
  {
    uncle_left=uncle->left;
    uncle_right=uncle->right;
    if(  (!uncle_left ||  uncle_left->m_color==BLACK )
         &&
         (!uncle_right  ||  uncle_right->m_color==BLACK))
      {
        uncle->m_color=RED;
        curnode=parent;


      }
    else
      {
        if( !uncle_right || (uncle_right&& uncle_right->m_color==RED))
   {
     uncle->m_color=parent->m_color;
     parent->m_color=BLACK;
     if(uncle_right)
       {
         uncle_right->m_color=BLACK;
       }

     rotate_left( parent,uncle);
     if (!uncle->parent)
       {
         node->root=uncle;
       }
     return ;

   }
        else
   {
     uncle_left->m_color=BLACK;
     uncle->m_color=RED;
     rotate_right(uncle_left,uncle);

     uncle=parent->right;
     uncle->right=uncle->right;

     uncle->m_color=parent->m_color;
     parent->m_color=BLACK;
                          uncle_right->m_color=BLACK;

     rotate_left( parent,uncle);
     if (!uncle->parent)
       {
         node->root=uncle;
       }
     return ;
   }

      }

  }

     }
   else
     {
       uncle=parent->left;
       if(!uncle)
  {
    return ;
  }

       if (uncle->m_color== RED)
  {
    uncle->m_color=BLACK;
    parent->m_color=RED;
    rotate_right (uncle ,parent);
    if (!uncle->parent)
      {
        node->root=uncle;
      }

  }
       else
  {
    uncle_left=uncle->left;
    uncle_right=uncle->right;
    if(  (!uncle_left ||  uncle_left->m_color==BLACK )
         &&
         (!uncle_right  ||  uncle_right->m_color==BLACK))
      {
        uncle->m_color=RED;
        curnode=parent;

      }
    else
      {
        if( !uncle_left || ( uncle_left &&  uncle_left->m_color==RED))
   {
     uncle->m_color=parent->m_color;
     parent->m_color=BLACK;
     if(uncle_left)
       {
         uncle_left->m_color=BLACK;
       }

     rotate_right( uncle , parent);
     if (!uncle->parent)
       {
         node->root=uncle;
       }
     return ;

   }
        else
   {
     uncle->m_color=RED;
     uncle_right->m_color=BLACK;
     rotate_left(  uncle ,uncle_right);

     uncle=parent->left;
     uncle_left=uncle->left;

     uncle->m_color=parent->m_color;
     parent->m_color=BLACK;
                          uncle_left->m_color=BLACK;

     rotate_right( uncle , parent);
     if (!uncle->parent)
       {
         node->root=uncle;
       }
     return ;
   }
      }

  }
     }
 }
    }
}

void  delete  (wrapdata  *node ,int  data)
{
  redblack  * drop;
  redblack  *suc;
  redblack  *curnode;
  int  value;
  int  mode;
 

  if ( drop=find ( node->root ,data))
    {
      printf("will  delete   %d \n",data);
      if(!drop->left  &&  !drop->right )
 {
   if (!drop->parent)
     {
       myfree(drop);
       node->root=0;
      
     }
   else
     {
       if (drop->parent->left==drop)
  {
    drop->parent->left=0;
  }
       else
  {
    drop->parent->right=0;
  }
       myfree  (drop);
     }
 }
      else  if (!drop->right )
 {
   if(!drop ->parent)
     {
       node->root=drop->left;
     }
   else
     {
       if (drop->parent->left==drop)
  {
    drop->parent->left=drop->left;
    mode=0;
  }
       else
  {
    drop->parent->right=drop->left;
    mode=1;
  }
     }

   curnode=drop->left;
   curnode->parent=drop->parent;
   myfree  (drop);
   delete_fixup (node, curnode,mode);

 }
      else
 {
   suc=next ( drop->right);
   value=drop->m_data;
   drop->m_data=suc->m_data;
   suc->m_data=value;

   if(suc->parent->left==suc)
     {
       mode=0;
     }
   else
     {
       mode=1;
     }

   if(!suc->right)
     {

       if(0==mode)
  {
    suc->parent->left=0;
  }
       else
  {
    suc->parent->right=0;
  }

       myfree(suc);
     }
   else
     {
       if(0==mode)
  {
    suc->parent->left=suc->right;
  }
       else
  {
    suc->parent->right=suc->right;
  }

       curnode=suc->right;
       curnode->parent=suc->parent;
       myfree(suc);
       delete_fixup  (node ,curnode,mode);

     }

 }
      node->size--;
    }
  else
    {
    }
  node->root->m_color=BLACK;
}

void  insert  ( wrapdata  *node , int  data )
{
  redblack  *newnode;
  redblack  *curnode;
  int  relation;

  node->size++;
  newnode=newstruct (data);
  printf("will  insert %x  %d \n",newnode,data);

  if ( ! node->root)
    {
      node->root= newnode;
    }
  else
    {
      curnode=node->root;
      while(1)
 {
   relation=compare(data,curnode);
   if(relation==-1)
     {
       node->size--;
       myfree(newnode);
       return ;
     }
   else
     {     
       if (   relation==1)
  {
    if (!curnode->right)
      {
        curnode->right=newnode;
        newnode->parent=curnode;

        break;
      }
    else
      {
        curnode=curnode->right;
      }
  }
       else
  {
    if (!curnode->left)
      {
        curnode->left=newnode;
        newnode->parent=curnode;
        break;
      }
    else
      {
        curnode=curnode->left;
      }
  }
     }
 }
      insert_fixup ( node , newnode);
    }
  node->root->m_color=BLACK;
}


int  main()
{
  int  i;
  wrapdata  *node;
  data  *newdata;
  int  count;

  init();
  srand(time(NULL));
  node=(wrapdata*)calloc (1  ,sizeof (wrapdata));
  global_node=node;

  /*
    int  value[]={12,24,25,9,4,91,2,100,98,95,93,96,99,120,13};
    //    int  value[]={12,24,25,9,4,91,2};
    node=(wrapdata*)calloc (1  ,sizeof (wrapdata));
    for (i=0;i<sizeof (value)/sizeof(int );i++)
    {
    insert (node ,value[i]);
    }

    printf("%d  \n",depth (node->root));
    mid_print (node->root,0);
    printf("\n");

 
    while(1)
    {
    printf("into  delete  mode\n");
    while( scanf("%d",&i)  &&  i)
    {
    delete  (node ,i);
    printf("%d  \n",depth (node->root));
    mid_print (node->root,0);
    printf("\n");
    }

    printf("into  insert  mode\n");
    while( scanf("%d",&i)  &&  i)
    {
    insert  (node ,i);
    printf("%d  \n",depth (node->root));
    mid_print (node->root,0);
    printf("\n");
    }

    }
  */

  while(1)
    {
      //     printf("into  insert  mode\n");
      while( node->size< COUNT)
 {
   i=rand()%RAND;
   insert  (node ,i);
   count=check(node->root);
   if(count)
     {
       //       printf("\ncheck  error\n");
       mid_print(node->root,0);
       return ;
     }
   count=mid_print (node->root,0);
   if(count!=node->size)
     {
       //      printf("\n  %d  %d  \n",count ,node->size);
       return ;
     }
   if(error_label)
     {
       return ;
     }
 
   if(node->size==COUNT*2/3)
     {
       printf("%d  %d  \n",node->size,depth (node->root));
     }
 
 }
     
      //      printf("into  delete  mode\n");
      while( node->size> COUNT/2)
 {
   i=rand()%RAND;
   delete  (node ,i);
   count=check(node->root);
   if(count)
     {
       //      printf("\ncheck  error\n");
       return ;
     }
   count=mid_print (node->root,0);
   if(count!=node->size)
     {
       //       printf("\n delete error  %d  %d  \n",count ,node->size);
       return ;
     }
   if(error_label)
     {
       return ;
     }
   if(node->size==COUNT*2/3)
     {
       printf("%d  %d  \n",node->size,depth (node->root));
     }
 
 }
    }
  return  0;
}

 

  

chenbingchenbing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux kernel中的红黑树及红黑树测试代码移植
08-11
提取linux kernel中的红黑树实现，供项目使用。可以在linux下编译运行。可以用来研究红黑树代码，已经在项目中使用。附上运行结果 xw@xw-virtual-machine:~/share/test/rbtree$ ./rbtest KERN_ALERT rbtree testing ...
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 16万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
七、二叉树、红黑树、HashSet集合、Map集合
电脑高级开关机工程师的博客
12-27 169
JavaSE进阶七，讲述了二叉树、红黑树、HashSet集合、Map集合
数据结构-----红黑树（全）
最新发布
m0_73633088的博客
10-17 399
本文详细讲解红黑树的增删改查操作，详细讨论红黑树插入和删除的多种情况，有图片说明，附有红黑树完整代码，保证你肯定能够学会红黑树，快进来看看吧！
基本数据结构之红黑树
qq_44182694的博客
01-28 1562
红黑树 红黑树（Red-Black Tree，R-B Tree）是一种自平衡的二叉查找树。在红黑树的每个节点上都多出一个存储位表示节点的颜色，颜色只能是红（Red）或者黑（Black）。 是根据AVL树进化而来的，由于AVL树每次插入都需要动态调整，这需要大量的时间，因此出现了红黑树。 红黑树不会像AVL树那样，每次插入都需要动态调整。因此当数据经常变化的时候，红黑树的效率要比AVL树要高。 红黑树的特性 红黑树的特性如下。 ◎ 每个节点或者是黑色的，或者是红色的。 ◎ 根节点是黑色的。 ◎ 每个叶子节点（
数据结构-红黑树
m0_61433144的博客
08-18 1059
红黑树也是一种二叉排序树，在红黑树中每个结点存储着对应的颜色(红色或者黑色)，由于AVL树的高度平衡是因为非常频繁地调用旋转来保存自身平衡的，代价较大。所以在AVL树的基础上进一步放宽条件，引入红黑树，即红黑树的最长路径不会比最短路径长两倍。......
红黑树的插入详细图解，直接拿下红黑树
08-17
红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。 它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的：...
链表和红黑树测试代码
10-09
linux内核双向环形链表和红黑树，源码学习，摘录部分代码编译成库，进行测试
C++数据结构 红黑树 实现全部功能
12-29
使用C++编写的红黑树源代码
红黑树插入删除的平衡操作
03-17
红黑树插入，删除时各种状态的平衡操作。
通用算法 - [树结构] - 红黑树
Olivaf的博客
03-06 739
红黑树
红黑树的应用开发及性能测试
raoping2017的博客
04-06 1587
1、概述 本文主要描述红黑树的概念、经典应用场景，并在应用开发层面示例代码说明红黑树的高效特性。 2、epoll 与红黑树 epoll 的高效就在于，当我们调用 epoll_ctl 保存上百万个句柄，epoll_wait 仍然可以飞快的返回，并有效的将发生事件的句柄给我们用户。这是因为我们在调用epoll_create 时，linux 内核除了帮我们在 epoll 文件系统里建了个 fi
红黑树的删除压力测试和完整性检查
weixin_30784501的博客
03-30 101
　　之前的文章写了红黑树的实现，因为自己实现了插入和删除的算法。为了测试算法的性能，以及算法的正确性，又写了几个函数，用来检查一棵树是否是红黑树，并进行压力测试，代码如下： 1 import 'dart:math'; 2 import 'package:data_struct/tree/tree.dart'; 3 4 void run() { 5 var size =...
红黑树介绍
Estrus5的博客
11-28 197
一、首先先来了解什么是2-3-4树 1.简介 2-3-4属于一种多路查找树，是一种四阶的B树，它的结果有以下特点： 所有叶子节点都拥有相同的深度 节点只能是2-节点、3-节点、4-节点节点 元素的排序整体上保持二叉查找树的特性,即父节点大于左子节点，小于右子节点；当节点有多个元素时，每个元素都必须大于他左边的和他的左子树中的元素。 2.三种节点的示意图 ①:2-节点:有两个子树的节点 ③:3-节点:有三个子树的节点 ④:4-节点:有四颗子树的节点 3.构建一颗2-3-4树 2-3-4树中结点添加需要遵
红黑树RBT存储结构
weixin_44055282的博客
04-13 908
红黑树RBT存储结构 a) 自平衡的二叉查找树 b) 1.节点是红色或黑色。 2.根节点是黑色。 3.每个叶子节点都是黑色的空节点（NIL节点）。 4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 5.从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 c) 维持自平衡可以变色与左右旋转 d) 应用：treeset/treemap、hashma...
深入理解红黑树与B+树应用场景
HiMark
09-29 1万+
红黑树和B树应用场景有何不同？ 2者都是有序数据结构，可用作数据容器。红黑树多用在内部排序，即全放在内存中的，微软STL的map和set的内部实现就是红黑树。B树多用在内存里放不下，大部分数据存储在外存上时。因为B树层数少，因此可以确保每次操作，读取磁盘的次数尽可能的少。 在数据较小，可以完全放到内存中时，红黑树的时间复杂度比B树低。反之，数据量较大，外存中占主要部分时，B树因其读磁盘次数少，而具...
红黑树的删除—10张图学会
早就戒了的博客
12-23 1万+
如果要学红黑树，那么就必须知道二叉树，毕竟红黑树本身就是一个二叉搜索树。只不过红黑树比一般的二叉搜索树更加稳定，也就是更加平衡，但是有没有AVL树那么的稳定，这换来的是红黑树比AVL数有更好的插入和删除效率，但是查找效率并没有比AVL差很多。下文我将用RBT代替红黑树。二叉搜索树的删除介绍RBT的删除，就先要知道二叉搜索树的删除(知道的同学可以直接跳过)。删除分为四步： 1.找到删除点假设为X
红黑树结构完整实现与详解
大昱的博客
06-27 8535
红黑树结构以平衡、高效的随机访问著称。实际使用过程中，其效率超出想象(节点数量越多，效率越高)，大部分情况下查找的节点数量小于节点总量的二分之一，最长的查询路径也才是总量的二分之一加一个节点的距离。 红黑树以黑色和红色用来标记根节点、枝节点与叶节点既有优势也有劣势(当然优势大于劣势)： 优势：在多次查询节点时高度保持树型的平衡(旋转情况下，不超过三次旋转，插入数据不超过两次旋转)； ...
浅析红黑树（RBTree）原理及实现
芮萌萌的博客
07-10 9万+
我们在上一篇博客认识到了平衡二叉树(AVLTree)，了解到AVL树的性质，其实平衡二叉树最大的作用就是查找,AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。AVL树的效率就是高在这个地方。如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状态就被破坏，它就不再是一棵二叉树；为了让它重新维持在一个平衡状态，就需要对其进行旋转处理, 那么创建一颗平衡二叉树的成...
为什么红黑树删除节点最多经过3次调整
05-29
红黑树的删除节点操作最多需要经过三次调整是因为，在删除节点的过程中，红黑树需要维护以下性质： 1. 节点是红色或黑色。 2. 根节点是黑色。 3. 所有叶子节点都是黑色（叶子节点为NIL节点）。 4. 每个红色节点必须...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值