My BTree by C++

最新推荐文章于 2024-04-14 09:29:38 发布
最新推荐文章于 2024-04-14 09:29:38 发布
阅读量619 收藏
点赞数
文章标签： null delete header insert c++ 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fice1989/article/details/6465036
版权

不太优良的B树。。。调了4天，终于大功告成了。。。

//========================================
//BTreeNode.h
//B树节点类的实现声明
//========================================

#ifndef HEADER_BTREENODE
#define HEADER_BTREENODE

//----------------------------------------
#include<iostream>
//----------------------------------------

const int m = 5; //BTree的阶数，暂定为5
typedef int KeyType;

class BTreeNode
{
public:

 int keyNum;
 KeyType key[m];
 BTreeNode * child[m+1];
 BTreeNode * parent;

 void sort()
 {
  //加入新元素后调整元素及孩子指针的顺序，以满足升序排列要求
  if(!isLeaf())
   for(int i = keyNum - 1; i > 0 ; i--)
   {
    if(key[i] >= key[i-1] && child[i+1]->key[0] >= child[i]->key[0])
     break;
    else
    {
     if(key[i] < key[i-1])
     {
      KeyType t;
      t = key[i];
      key[i] = key[i-1];
      key[i-1] = t;
     }

     if(child[i+1]->key[0] < child[i]->key[0])
     {
      BTreeNode * pt;
      pt = child[i+1];
      child[i+1] = child[i];
      child[i] = pt;
     }
    }
   }
  
  else
  {
   for(int i = 1; i < m+1; i++)
    child[i] = NULL;

   for(int i = keyNum - 1; i > 0 ; i--)
   {
    
    if(key[i] >= key[i-1])
     break;
    else
    {
     if(key[i] < key[i-1])
     {
      KeyType t;
      t = key[i];
      key[i] = key[i-1];
      key[i-1] = t;
     }
    }
   }
  }
 }


 BTreeNode()
 {
  keyNum = 0;

  for(int i = 0; i < m+1; i++)
  {
   child[i] = NULL;
  }

  parent = NULL;
 }

 BTreeNode( KeyType & e,BTreeNode * first = NULL,BTreeNode * second = NULL,BTreeNode * p = NULL)
 {
  for(int i = 0; i < m+1; i++)
   child[i] = NULL;

  keyNum = 1;
  key[0] = e;
  child[0] = first;
  child[1] = second;
  parent = p;

 }

 ~BTreeNode() {}

 bool insertVal(KeyType & k,BTreeNode * nd = NULL)
 {
  //该结点数据存储已满，无法再插入数据
  
  key[keyNum] = k;
  child[keyNum+1] = nd;
  keyNum++;
  sort();
   
  if(keyNum >= m)
   return false;
  else
   return true;   

 }
 
 bool remove(int n)
 {
 
  for(int i = n; i < keyNum - 1; i++)
  {
   key[i] = key[i+1];
   child[i+1] = child[i+2];
  }
  keyNum--;

  return true;
 }

 bool removeLeafKey(KeyType & k)
 {
  //对叶子节点中的key进行删除

  if(!isLeaf())
   return false;

  int i = 0;

  while(i < keyNum && k != key[i])
   i++;
  
  if(i == keyNum)
   return false;
  else
  {
   for(int j = i; j < keyNum - 1; j++)
   {
    key[j] = key[j+1];
    child[i+1] = child[i+2];
   }   

   keyNum--;
   return true;
  }

 }


 bool isLeaf()
 {
  if(child[0] == NULL)
   return true;
  else
   return false;
 }

};
#endif //HEADER_BTREENODE

//========================================
//BTree.h
//B树类的声明
//========================================

#ifndef HEADER_BTREE
#define HEADER_BTREE

//---------------------------------------
#include "BTreeNode.h"
//---------------------------------------
class BTree
{
public:
 BTreeNode * root;
 int level;  //记录B树的层数

 BTree() {root = NULL; level = 0;}
 ~BTree() {clear();}

 BTreeNode * findhelp(BTreeNode * subroot,KeyType & k,int & pos) ;
 void clearhelp(BTreeNode * subroot);
 void printhelp(BTreeNode * subroot,int level) ;
 
 //重新调整以subroot为根节点的子树的所有节点的parent值
 void resetParent(BTreeNode * subroot); 

 BTreeNode * isBroCan(BTreeNode * node);

 void clear()
 {
  clearhelp(root);
  root = NULL;
  level = 0;
 }

 bool insert(KeyType & k);

 bool remove( KeyType & k);

 BTreeNode * find( KeyType & k,int & pos)
 {
  return findhelp(root,k,pos);
 }

};

#endif //HEADER_BTREE

 

 

//========================================
//BTree.cpp
//B树类的实现
//========================================

#include "BTree.h"
//-----------------------------------------
void BTree::clearhelp(BTreeNode * subroot)
{
 if( subroot == NULL )
  return;

 if( subroot -> isLeaf() )
 {
  delete subroot;
  return;
 } 

 for(int i = subroot->keyNum; i >= 0; i--)
 {
  clearhelp(subroot -> child[i]);
  subroot->child[i] = NULL;
 }
 
 delete subroot;
 
}
//-----------------------------------------
void BTree::resetParent(BTreeNode * subroot)
{
 if(subroot == NULL || subroot->isLeaf())
  return;
 
 for(int i = 0; i <= subroot->keyNum; i++)
 {
  subroot->child[i]->parent = subroot;
  resetParent(subroot->child[i]);
 }
 
}                                 
//-----------------------------------------
BTreeNode * BTree::isBroCan(BTreeNode * node)
{
 if(node == root || node == NULL)
  return NULL;

 BTreeNode * p = node->parent;

 //t用于定位该节点是父节点的第t个孩子
 int t = 0;
 while(t < node->parent->keyNum)
 {
  if(node->parent->key[t] < node->key[0])
   t++;
  else
   break;
 } 

 if(t == 0)
 {
  if(node->parent->child[t+1]->keyNum > m/2)
   return node->parent->child[t+1];
  else
   return NULL;
 }

 else if(t == node->parent->keyNum)
 {
  if(node->parent->child[t-1]->keyNum > m/2)
   return node->parent->child[t-1];
  else
   return NULL;
 }

 else
 {
  if(node->parent->child[t+1]->keyNum > m/2)
   return node->parent->child[t+1];
  else if(node->parent->child[t-1]->keyNum > m/2)
   return node->parent->child[t-1];
  else
   return NULL;

 }

 return NULL;
}

//-----------------------------------------
BTreeNode * BTree::findhelp(BTreeNode * subroot, KeyType & k,int & pos)
{
 if(subroot == NULL)
  return NULL;

 for(int i = 0; i < subroot->keyNum; i++)
 {
  if( k < subroot->key[i] )
   return findhelp( subroot->child[i], k ,pos);

  else if( k == subroot->key[i] )
  {
   pos = i;
   return subroot;
  }
 }

 return findhelp( subroot->child[subroot->keyNum] ,k,pos);

}
//-----------------------------------------
bool BTree::insert(KeyType & k)
{
 //当该树为空
 if(root == NULL)
 {
  root = new BTreeNode (k);
  level++;
  return true;
 }

 //不为空则找到一个叶结点node并将k插入
 BTreeNode * node = root;

 while(!node->isLeaf())
 {
  if(k > node->key[node->keyNum - 1])
   node = node->child[node->keyNum];

  else
   for(int i = 0; i < node->keyNum; i++)
    if( k < node->key[i] )
    {
     node = node->child[i];
     break;
    }

    else if( k == node->key[i] )
     return false;
  
 }
 
 while(true)
 {
  static BTreeNode * node1 = NULL;
  static BTreeNode * node2 = NULL;

  if(node->insertVal(k,node2)) 
  {
   //若节点node未上溢

   resetParent(root); //重新调整node以下的各节点的parents值
   return true;
  }
 
  else
  {
   //若发生上溢
   node1 = node;
   node2 = new BTreeNode; //(node->key[3],node->key[4],node->child[],NULL,node->parent);
   
   int j,i;
   for(j = 0 , i = m/2+1; i < m; i++,j++)
   {
    node2->key[j] = node->key[i];
    node2->child[j] = node->child[i];  
   }
   node2->child[j] = node->child[i];
   
   node2->parent = node1->parent;

   k = node->key[m/2];
   node1->keyNum = m/2;
   node2->keyNum = m/2;


   if(node == root)
   {
    root = new BTreeNode (k,node1,node2,NULL);
    root->child[0]->parent = root;
    root->child[1]->parent = root;

    level++;
    resetParent(root);
    return true;
   }

   else
    node = node->parent;
  
  }

 }
 
 return true;
}
//-----------------------------------------
bool BTree::remove( KeyType & k)
{
 int pos;
 BTreeNode * node = findhelp(root,k,pos);
 
 if(node == NULL)
  return false;

 else
 {

  if(!node->isLeaf())
  {
   //找到k的直接前驱s所在的叶子结点，用s覆盖node中的k
   //node赋值为含s叶子结点
   //从node中删除s
   BTreeNode * t = node->child[pos];
   while(!t->isLeaf())
    t = t->child[ t->keyNum ];

   node->key[pos] = t->key[ t->keyNum - 1 ];
   t->remove(t->keyNum - 1);
   node = t;
   
  }
  
  else
   node->removeLeafKey(k);

  while(true)
  {
   if(node->keyNum >= m/2)
    return true;
   
   //如果node的一个兄弟结点中有足够的key
   else if(BTreeNode * bro = isBroCan(node))
   {
     int t = 0;
    while(t <= node->parent->keyNum)
    {
     if(node->parent->key[t] < node->key[0])
      t++;
     else
      break;
    } 

    //在node及bro中重新分配key
    if(node->key[0] > bro->key[0])
    {
     node->insertVal(node->parent->key[t-1]);
     node->parent->key[t-1] = bro->key[bro->keyNum - 1];
     bro->remove(bro->keyNum - 1);
    }

    else
    {
     node->insertVal(node->parent->key[t]);
     node->parent->key[t] = bro->key[0];
     bro->remove(0);
    
    }

    return true;    
   }

   //如果node的父结点为根
   else if(node->parent == root)
   {

    //如果父节点只有一个key
    if(node->parent->keyNum == 1)
    {
     //将root、node及兄弟结点合并成新的根
     root->child[0]->insertVal(root->key[0],root->child[1]);
     for(int i = 0; i < root->child[1]->keyNum; i++)
     {
      root->child[0]->child[ root->child[0]->keyNum ] = root->child[1]->child[i];
      root->child[0]->insertVal(root->child[1]->key[i],root->child[1]->child[i+1]);
     }
     
     BTreeNode * t = root;
     root = root->child[0];
     root->parent = NULL;
     resetParent(root);
     level--;
     delete t->child[1];
     delete t;
     
     return true;
    }


    else
    {
     //合并node及兄弟结点

     if(node->key[0] < root->key[0])
     {
      node->insertVal(root->key[0]);
      for(int i = 0; i < root->child[1]->keyNum; i++)
      {
       node->child[ node->keyNum ] = root->child[1]->child[i];
       node->insertVal(root->child[1]->key[i]);
      }
      node->child[ node->keyNum ] = root->child[1]->child[ root->child[1]->keyNum ];
      root->remove(0);
     }

     else
     { 
      int t = 0;
      while(t <= node->parent->keyNum)
      {
       if(node->parent->key[t] < node->key[0])
        t++;
       else
        break;
      } 

      root->child[t]->insertVal(root->key[t]);

      for(int i = 0; i < node->keyNum; i++)
      {
       root->child[t]->child[ root->child[t]->keyNum ] = node->child[i];
       root->child[t]->insertVal(node->key[i]);
      }
      root->child[t]->child[ root->child[t]->keyNum ] = node->child[ node->keyNum ];

      delete node;
      root->remove(t);

     }

     return true;
    }
   
   
   } //else if(node->parent == root)
  
  
   else
   {
    //合并node及兄弟结点

    if(node->key[0] < node->parent->key[0])
    {
     node->insertVal(node->parent->key[0]);
     for(int i = 0; i < node->parent->child[1]->keyNum; i++)
     {
      node->child[ node->keyNum ] = node->parent->child[1]->child[i];
      node->insertVal(node->parent->child[1]->key[i]);
     }
     node->child[ node->keyNum ] = node->parent->child[1]->child[ node->parent->child[1]->keyNum ];
     node->parent->remove(0);
    }

    else
    {
     int t = 0;
     while(t <= node->parent->keyNum)
     {
      if(node->parent->key[t] < node->key[0])
       t++;
      else
       break;
     } 

     node->parent->child[t]->insertVal(node->parent->key[t]);

     for(int i = 0; i < node->keyNum; i++)
     {
      node->parent->child[t]->child[ node->parent->child[t]->keyNum ] = node->child[i];
      node->parent->child[t]->insertVal(node->key[i]);
     }
     node->parent->child[t]->child[ node->parent->child[t]->keyNum ] = node->child[ node->keyNum ];

     delete node;
     node->parent->remove(t);

    }


    node = node->parent;
   }
  
  } //while(true)
 
 }

}

fice1989
关注
B-Tree的C++实现
Lynn
11-03 1495
简要说明下B树的性质。 用M表示B树的阶数，L表示叶子节点的最大元素个  （性质说明来自于《数据结构与问题求解(C++版)》第19章）  1、数据项保存在叶子中  2、非叶子节点具有M-1个键指导查找的进行；键i代表子树i+1中最小的键  3、根要么是叶子，要么就有2～M个孩子  4、所有非叶子节点，(根除外)都具有[M/2]～M个孩子  5、所有叶子都在同一深度，并且对某一叶子，具
C++算法与数据结构大全
wu_chang_yu的博客
06-28 1613
本文整理了各种算法与数据结构，并给出了C++实现。本文仍在不断更新中，敬请期待。 查找算法 Binary Search #include <iostream> using namespace std; int binary_search(int a[], int l, int r, int key) { while (l <= r) { int m = l + (r - l) / 2; if (key == a[m]) return m; else if (key &
Btree(B-树)---C++
weixin_34413065的博客
05-07 146
一棵M阶(M>2)的B树，是一棵平衡的M路平衡搜索树，可以是空树或者满足一下性质：1. 根节点至少有两个孩子2. 每个非根节点有[ ,M]个孩子3. 每个非根节点有[ -1,M-1]个关键字，并且以升序排列4. key[i]和key[i+1]之间的孩子节点的值介于key[i]、key[i+1]之间5. 所有的叶子节点都在同一层ps： 是向上取整#pragmaonce ...
B树（B-tree）c++语言
m0_61862494的博客
03-07 239
B树可以自平衡，这意味着每次插入和删除操作后，B树都可以通过旋转和重构节点来保持平衡。这种自平衡的特性使得B树可以应对动态的数据存储需求，同时保持高效的查询和修改操作。B树的节点大小通常和磁盘块大小相同，因此可以直接在磁盘上存储B树。B树可以存储大量的数据，因为它可以在节点中存储多个关键字和指向子节点的指针。B树的查询和修改操作的时间复杂度为O(log n)，其中n是B树中存储的关键字数量。因此，B树被广泛应用于文件系统、数据库管理系统、存储系统和其他需要高效存储和管理大量数据的应用中。
C++实现B-Tree（B-树）
weixin_43462583的博客
08-05 281
key: key0 key1 key2 key3 key4 (存数值)child: child0 child1 child2 child3 child4 child5 (存指针)
C++实现BTree代码
最新发布
nothing
04-14 347
C++实现BTree代码
2022年MySQL最新面试题
漫步coding
04-02 7271
前言 最近整理一份关于MySQL常见面试题的，也会根据自己的经验， 标注一些出现的概率，最高5颗★出现的概率最高。比如这样: 百万级别或以上的数据如何删除 出现概率: ★★★ 一般来讲在面试当中， 关于数据库相关的面试题频率出现比较高的几个关键词是SQL优化、索引、存储引擎、事务、死锁、乐观锁、悲观锁、关系型数据库和非关系数据库对比等等。 把这几个点问完基本也差不多10~20分钟了(一般一轮面试1小时左右), 基本这些可以让面试官对你的数据库知识有一定的了解了。 如果你线上运维经验, 一般也会问一些比如数据
数据库 - MySQL基础知识
questionulic的博客
03-22 940
数据库 - MySQL 1. CentOS 下 MySQL 的安装 在官网下载相应的 rpm 软件包，并安装 wget ... yum -y install ... 更新安装的软件 yum update 安装 MySQL server yum install mysql-server 运行 mysqld 并查看运行状态 systemctl start mysqld systemctl status mysqld 查找默认密码 grep "password" /var/log/my
看了这篇MySQL，开发功力又升级
lt_xiaodou的博客
10-11 140
MySQL官方对索引的定义为：索引（Index）是帮助MySQL高效获取数据的数据结构。索引是数据结构。目的在于提高查询效率，可以类比字典。简单理解为“排好序的快速查找数据结构”：在数据之外，数据库系统还维护着满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据。
03.MySQL高级
weixin_48699240的博客
08-11 295
第1章MySQL简介 1.1 什么是Mysql 1） MySQL是一个关系型数据库管理系统，由瑞典MySQL AB公司开发，目前属于Oracle公司。 2） Mysql是开源的，可以定制的，采用了GPL协议，你可以修改源码来开发自己的Mysql系统。 3） MySQL使用标准的SQL数据语言形式。 4） Mysql可以允许于多个系统上，并且支持多种语言。这些编程语言包括C、C++、Python、Java、Perl、PHP、Eiffel、Ruby和Tcl等。 5） MySQL支持大型数据库，支持5000万条记
BTree数据结构课程设计C++版
01-15
BTree数据结构课程设计C++版，完整的过程和C++源代码，包括算法的源代码等。C++代码可以直接运行。
BTree的c++源码
11-21
用c++实现数据结构中的B树。1970年，R.Bayer和E.mccreight提出了一种适用于外查找的树，它是一种平衡的多叉树，称为B树，
cpp-btree:现代 C++ B 树容器
05-29
C ++ B树 此存储库中的代码基于。 C++ B-tree 是一个模板库，它基于 B-tree 数据结构实现有序的内存容器。 类似于 STL std::map 、 std::set 、 std::multimap和std::multiset模板，这个库提供了btree::map 、 btree::set 、 btree::multimap和btree::multiset 。 这与 Google 的原始项目不同，因为容器的行为更像现代 STL (C++17)，并且几乎是直接替换（迭代器失效除外，见下文）； 对于包括支持emplace和try_emplace在地图和值不需要有一个默认的构造函数。 与通常使用红黑树实现的标准容器相比，C++ B 树容器具有一些优势。 红黑树中的节点每个条目需要三个指针（加上 1 位），而 B 树平均每个条目使用少于一个指针，从而显着节省内存。 例如， s
【BTree、B-树】B树的C++实现
ArchyLi
11-25 4118
一、B树的概念B树是平衡的多叉树，一个节点有多于两个（不能小于）结点的平衡多叉树。由于B树倒着生长所以平衡。缺点：浪费空间二、B树满足以下性质：1、根结点至少有两个孩子。[2，M]个孩子 2、每个非根结点有【（M/2），M】个孩子。 3、每个非根结点有【（M/2-1），M-1】个关键字，并且以升序排序。 4、每个结点孩 5、key[i]和key[i+1]之间的孩子节点的值介于key[i]、k
找出BTree最小深度（根节点到叶节点最短路径上节点的个数）C++实现
paradox_1_0的博客
06-23 299
#include<stdio.h> #include<stdlib.h> #include<string.h> struct TreeNode { TreeNode(): left(NULL), right(NULL){ } TreeNode *left; TreeNode *right; int data; }; int run(TreeNo...
多路平衡树(BTree)的C++实现
weixin_30800807的博客
03-04 209
　　B树是一种多路平衡树，我根据《算法导论》中的算法描述实现了C++版本的BTree。关于BTree的各种属性看这里吧，还有别人的实现版本，看这里。我记得书中并没有给出删除的算法，这个部分我是根据书中的描述自己实现的。完成后自己进行过简单的测试，好像没有什么问题。总共是两个文件BTree.h和Test.cpp，BTree的实现在BTree.h文件中。Test.cpp是测试案例。具体代码如下： ...
mysql索引原理
heroking
09-04 211
1. 摘要 本文以MySQL数据库为研究对象，讨论与数据库索引相关的一些话题。特别需要说明的是，MySQL支持诸多存储引擎，而各种存储引擎对索引的支持也各不相同，因此MySQL数据库支持多种索引类型，如BTree索引，哈希索引，全文索引等等。为了避免混乱，本文将只关注于BTree索引，因为这是平常使用MySQL时主要打交道的索引，至于哈希索引和全文索引本文暂不讨论。 文章主要内容分为三个部分。 第...
类stl的btree模板
larrin的Blog
04-28 1076
    最近写了一个类似stl的btree，拿出来与大家共享一下。这个btree的用法与stl中的map非常相似。我在vc7.1和redhat（gcc 3.2）中编译成功。btree未经过严格测试，欢迎大家一起来测试完善他。     如果发现有什么问题，或者有什么建议，可以跟我联系。联系方式：larrin2002@msn.com。1.btree源码#ifndef _LARRIN_WORKSHOP_
数据结构——B-树（c++）
weixin_48560325的博客
05-18 2997
简介 在计算机科学中，B树（英语：B-tree）是一种自平衡的树，能够保持数据有序。这种数据结构能够让查找数据、顺序访问、插入数据及删除的动作，都在对数时间内完成。B树，概括来说是一个一般化的二叉查找树（binary search tree），可以拥有多于2个子节点。与自平衡二叉查找树不同，B树为系统大块数据的读写操作做了优化。B树减少定位记录时所经历的中间过程，从而加快存取速度。B树这种数据结构可以用来描述外部存储。这种数据结构常被应用在数据库和文件系统的实现上。 定义 一颗m阶B-T...
btree 索引 实现 c++
08-17
B树是一种平衡多路搜索树，在数据库索引中被广泛应用。在C语言中实现B树索引可以通过以下步骤： 第一步，定义B树的数据结构。B树节点由关键字和指向子节点的指针组成。具体而言，可以使用结构体来表示B树节点，并在结构体中定义关键字和指针的数据类型。 第二步，实现插入操作。在B树中插入一个新的关键字，需要遵循一定的规则。首先，从根节点开始查找并找到合适的叶子节点。如果该叶子节点的关键字个数小于节点容量，则直接插入新的关键字。如果关键字个数达到容量，需要进行分裂操作，将关键字一分为二，并调整父节点指针。如果父节点关键字个数也达到容量，递归进行分裂操作，直到根节点。插入完成后，要确保整个B树仍然保持平衡性。 第三步，实现删除操作。在B树中删除一个关键字，同样需要遵循一定的规则。首先，从根节点开始查找并找到含有该关键字的叶子节点。如果叶子节点的关键字个数大于最小容量，则直接删除该关键字。如果小于最小容量，则需要进行合并或借用操作。接下来，从该关键字所在的叶子节点开始调整整个B树的平衡性。 第四步，实现查找操作。在B树中查找一个关键字，首先从根节点开始依次比较关键字大小，根据指针判断下一步移动的位置，直到找到该关键字或遍历完整个B树。 以上是用C语言实现B树索引的基本步骤。在实际应用中，还可以优化其性能，比如通过缓存策略减少磁盘I/O操作，或者使用前缀压缩技术减少存储空间。同时，为了保证数据的一致性和持久性，还需要实现日志记录、事务管理和并发控制等功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值