红黑树用来存储单个汉字GBK编码

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

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


#define   RAND   10000
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;
  char  gbk[5]={0};
  if(level>40)
    {
      printf("error\n");
      error_label=1;
      return 100000 ;
    }
  if (!root)
    {
      return  0;
    }
  else
    {
      right= mid_print  (root  ->right,level+1);
      gbk[0]=root->m_data/256;
      gbk[1]=root->m_data%256;
      //      printf("{address=%x color=%s,level=%d ,value=%s}   ",root ,root->m_color==RED?"red":"black",level ,gbk);
      printf("%s%d",gbk,root->m_data);
      //   printf(" %d   ",root->m_data->value);
      left=mid_print (root ->left,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;
  int  word_count;
  int  word_buffer[RAND]={0};

  FILE *fp = NULL;
  char buffer[64] = "";
  uint value = 0;
  char *pvalue = NULL;
  int weight = 0;
  int ikeylen = 0;
  char strFilePath[128] = "";

  char  buf[100]="";
  unsigned char word[100]="\0";
  int  gbk=0;


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


  getcwd(buf, sizeof(buf)-1);
  sprintf(strFilePath, "%s/%s", buf ,"single.txt");
  fp = fopen(strFilePath, "rt");


  word_count=0;
  while (fgets(buffer, sizeof(buffer) - 1, fp) > 0)
    {

      pvalue = (char *)memchr(buffer, '\t', sizeof(buffer));
      ikeylen = (pvalue - buffer);
      memcpy( word ,buffer ,ikeylen);

      //      printf("add  word  %s ",buffer);
      gbk=word[0] * 256 + word[1];
      insert(node ,gbk);
      word_buffer[word_count++]=gbk;
    }
  fclose(fp);


  while(1)
    {

 

      //     printf("into  insert  mode\n");
      while( node->size< word_count)
 {
   i=rand()%word_count;
   insert  (node ,word_buffer[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==word_count*2/3)
     {
       //       mid_print(node->root,0);
       printf("%d  %d  \n",node->size,depth (node->root));

     }
 
 }
      //      mid_print(node->root,0);     
      //      printf("into  delete  mode\n");
      while( node->size> word_count/2)
 {
   i=rand()%word_count;
   delete  (node ,word_buffer[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==word_count*2/3)
     {
       //       mid_print(node->root,0);
       printf("%d  %d  \n",node->size,depth (node->root));
     }
 
 }
    }
  return  0;
}

 

  

chenbingchenbing
关注
专栏目录
数据结构-红黑树
m0_61482125的博客
11-28 444
主要介绍了数据结构，2-3-4树的特性，红黑树的性质和建立方法。
MySql技术内 幕：InnoDB存储引擎 读书笔记
qq_33275348的博客
12-06 605
书名 《MySql技术内幕：InnoDB存储引擎》 作者 姜承尧 书摘 第一章：MySQL体系结构和存储引擎 定义数据库和实例： 定义数据库和实例 数据库：文件的集合，frm、MYD、MYI、ibd等 实例：是有后台线程以及一个共享内存区组成。操作数据库文件。单进程...
经过自动压力测试的红黑树(删除功能完备)
chenbingchenbing的专栏
11-28 706
#include  #include  #define   COUNT   10000 #define   RAND    (4*COUNT) int  error_label=0; #pragma  pack(1) typedef   enum  _color   {     RED,     BLACK   }color; typedef   struct  _d
红黑树介绍
Estrus5的博客
11-28 233
一、首先先来了解什么是2-3-4树 1.简介 2-3-4属于一种多路查找树，是一种四阶的B树，它的结果有以下特点： 所有叶子节点都拥有相同的深度 节点只能是2-节点、3-节点、4-节点节点 元素的排序整体上保持二叉查找树的特性,即父节点大于左子节点，小于右子节点；当节点有多个元素时，每个元素都必须大于他左边的和他的左子树中的元素。 2.三种节点的示意图 ①:2-节点:有两个子树的节点 ③:3-节点:有三个子树的节点 ④:4-节点:有四颗子树的节点 3.构建一颗2-3-4树 2-3-4树中结点添加需要遵
红黑树/缓存
疯狂程序员
10-01 854
-
红黑树RBT存储结构
weixin_44055282的博客
04-13 958
红黑树RBT存储结构 a) 自平衡的二叉查找树 b) 1.节点是红色或黑色。 2.根节点是黑色。 3.每个叶子节点都是黑色的空节点（NIL节点）。 4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 5.从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 c) 维持自平衡可以变色与左右旋转 d) 应用：treeset/treemap、hashma...
Java知识点概览
qq_48403611的博客
08-03 3489
java后端开发常见面试题总结
Java笔试面试题解答
最新发布
07-25
- **GBK**: 中国国家标准，用于中文编码。 **10. 企业系统架构** - **分层架构**: 分为表示层、业务逻辑层和数据访问层。 - **微服务架构**: 将应用拆分为多个独立部署的小服务。 **11. MVC框架关键组成部分** -...
Java面试手册（包含JavaSE+并发编程+数据库MySQL+Typora软件）
我要好好当个计院狗
05-26 407
Java面试
Java知识点梳理（详细）
msbjy的博客
04-09 489
1. Java中的数据类型 基本数据类型特征表 类型 位数 最小值 最大值 默认值 其他 byte 8 -128(-2^7) 127(2^7-1) 0 有符号、二进制补码表示 short 16 -32768(-2^15) 32767(2^15-1) 0 有符号、二进制补码表示 int 32 -2^31 2^31-1 0 有符号、二进制补码表示 long 64 -2^63 2^63-1 0L(0l) 有符号、二进制补码表示 float 32 2^(-149) 2^128-1 0.0f 单精度、I
【算法】红黑树删除数据（最后一步，平衡红黑树）（五）
lsr40的博客
02-01 1991
老话说一说，本人菜鸡，如果文章中有错误请大家批评指出！！！ 该系列已经全部更完，有5篇文章： 【算法】红黑树（二叉树）概念与查询（一）：https://blog.csdn.net/lsr40/article/details/85230703 【算法】红黑树插入数据（变色，左旋、右旋）（二）：https://blog.csdn.net/lsr40/article/details/8...
以红黑树为基础实现大数据聚类、有序的存储管理
baidu_41680168的博客
01-26 2078
画图说明什么的太累了 直接看源码吧 1.以红黑树为基础，聚类存储数据 2.红黑树节点以rb_tree_leaf 结构存放数据块，结构体rb_tree_leaf  成员data 以泛型形式指向实际数据块 3.红黑树排序规则可设置 4.存储数据块以__VecQue模板实现，内部实现二分顺序存储规则。数据逻辑规则可设置 testmain.cpp     #include &lt;s...
红黑树的删除压力测试和完整性检查
weixin_30784501的博客
03-30 121
　　之前的文章写了红黑树的实现，因为自己实现了插入和删除的算法。为了测试算法的性能，以及算法的正确性，又写了几个函数，用来检查一棵树是否是红黑树，并进行压力测试，代码如下： 1 import 'dart:math'; 2 import 'package:data_struct/tree/tree.dart'; 3 4 void run() { 5 var size =...
红黑树
jhkj_5154的博客
07-30 2894
可能在历史上最负盛名的二叉树：红黑树   红黑树：对每一个节点都附着了一个颜色，或者是红色或者是黑色。对于红黑树这种数据结构来说，相对是有些复杂的。 我们在《算法导论》中发现红黑树要满足五个条件： 首先红黑树是一颗二分搜索树，这一点与AVL树是一样的。红黑树在二分搜索树的基础上和AVL树一样，添加了一些其他的性质来保证他不会退化成为链表。也就是来保证自己是一棵平衡的二叉树。 1.每个...
数据结构-----红黑树（全）
m0_73633088的博客
10-17 1784
本文详细讲解红黑树的增删改查操作，详细讨论红黑树插入和删除的多种情况，有图片说明，附有红黑树完整代码，保证你肯定能够学会红黑树，快进来看看吧！
有序的数据结构中：内存操作红黑树快，磁盘操作b+树快
weixin_30375427的博客
12-14 279
红黑树常用于存储内存中的有序数据，增删很快，b+树常用于文件系统和数据库索引，因为b树的子节点大于红黑树，红黑树只能有2个子节点，b树子节点大于2，子节点树多这一特点保证了存储相同大小的数据，树的高度更小，数据局部更加紧凑，而硬盘读取有局部加载的优化（把要读取数据和周围的数据一起预先读取），b树相邻数据物理上更加紧凑这一特点符合硬盘进行io优化的特性。b+树在b树基础上进一步将数据只存在叶子节点，...
Two Sum 的map函数
WYR2446541820的博客
01-18 562
vector& nums声明一个动态的数组，  results.push_back是对数组赋值 刚刚开始是用两个for循环，但是时间复杂度为n^2，在网上查到了用map写法，果然ACCEPT，所以今天研究一下map函数以及其原因。 TWO SUM 的C++函数如下所示 class Solution { public:     vector twoSum(vector& nums,
基本数据结构之红黑树
qq_44182694的博客
01-28 1670
红黑树 红黑树（Red-Black Tree，R-B Tree）是一种自平衡的二叉查找树。在红黑树的每个节点上都多出一个存储位表示节点的颜色，颜色只能是红（Red）或者黑（Black）。 是根据AVL树进化而来的，由于AVL树每次插入都需要动态调整，这需要大量的时间，因此出现了红黑树。 红黑树不会像AVL树那样，每次插入都需要动态调整。因此当数据经常变化的时候，红黑树的效率要比AVL树要高。 红黑树的特性 红黑树的特性如下。 ◎ 每个节点或者是黑色的，或者是红色的。 ◎ 根节点是黑色的。 ◎ 每个叶子节点（
C语言实现红黑树数据结构
"红黑树是一种自平衡二叉查找树，它的每个节点包含一个颜色属性，可以是红色或黑色。这个C语言版本的红黑树实现包括了节点定义、树结构定义以及各种操作函数，如旋转、插入、删除等。代码参考了《算法导论》中的相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值