算法导论18（B树）

最新推荐文章于 2021-01-17 17:29:18 发布
最新推荐文章于 2021-01-17 17:29:18 发布
阅读量731 收藏
点赞数
分类专栏： 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hz5034/article/details/45727151
版权

插入
BTreeInsert(node *&root,char k)的工作原理
若root是一个满结点，分配一个空结点tmp，让root成为tmp的孩子，让tmp成为新的root，调用BTreeSplitChild(root,1)，调用BTreeInsertNonfull(root,k)；否则，直接调用BTreeInsertNonfull(root,k)。

BTreeSplitChild(node *x,int i)的工作原理
//x是一个非满结点，x->c[i]是一个满结点
x->c[i]分裂，x->c[i]的中间结点升至x。

BTreeInsertNonfull(node *x,char k)的工作原理
//x是一个非满结点
（1）x是叶结点：
直接将k插入x
（2）x是内部结点：
若x->c[i]是一个满结点，调用BTreeSplitChild(x,i)，递归调用BTreeInsertNonfull(x->c[i],k)；否则，直接递归调用BTreeInsertNonfull(x->c[i],k)。

删除
BTreeInsert(node *&root,char k)的工作原理
若root只包含一个关键字，root是内部结点，且root->c[1]和root->c[2]都只包含t-1个关键字，调用BTreeMergeChild(root,1)，删除root，让root->c[1]成为新的root，调用BTreeDeleteNonempty(root,k)；否则，直接调用BTreeDeleteNonempty(root,k)。

BTreeMergeChild(node *x,int i)的工作原理
//x至少包含t个关键字，x->c[i]和x->c[i+1]都只包含t-1个关键字
把x->key[i]和x->c[i+1]合并进x->c[i]，删除x中的x->key[i]，删除x->c[i+1]。

BTreeInsertNonempty(node *x,char k)的工作原理
//x至少包含t个关键字
（1）关键字k在结点x中，且x是叶结点：
直接删除x中的k。
（2）关键字k在结点x中，且x是内部结点：
a）x->c[i]至少包含t个关键字：
在x中用k的直接前驱k’代替k，递归调用BTreeInsertNonempty(x->c[i],k’)。
b）x->c[i+1]至少包含t个关键字：
在x中用k的直接后继k’代替k，递归调用BTreeInsertNonempty(x->c[i+1],k’)。
c）x->c[i]和x->c[i+1]都只包含t-1个关键字：
调用BTreeMergeChild(x,i)，递归调用BTreeDeleteNonempty(x->c[i],k)。
（3）关键字k不在结点x中：
a）x->c[i]只包含t-1个关键字，且x的相邻兄弟至少包含t个关键字：
x向x的相邻兄弟借一个关键字，递归调用BTreeDeleteNonempty(x->c[i],k)。
b）x->c[i]只包含t-1个关键字，且x的相邻兄弟都只包含t个关键字：
合并x和x的相邻兄弟，递归调用BTreeDeleteNonempty(x->c[i-1],k)（左兄弟）或BTreeDeleteNonempty(x->c[i],k)（右兄弟）
c）x->c[i]至少包含t个关键字：
直接递归调用BTreeDeleteNonempty(x->c[i],k)。

#include<iostream>
#include<string>
using namespace std;

const int t=2;

struct node
{
    int n;
    char key[2*t];   //key[0]保留，只使用key[1..2*t-1]
    bool leaf;
    node *c[2*t+1];   //c[0]保留,只使用c[1..2*t]
    node(int a,bool b):n(a),leaf(b){}
};

void BTreeCreate(node *&root)
{
    root=new node(0,true);
}

//x是一个非满结点，x->c[i]是一个满结点
void BTreeSplitChild(node *x,int i)
{
    node *y=x->c[i];
    node *z=new node(t-1,y->leaf);
    for(int j=1;j<=t-1;++j)z->key[j]=y->key[t+j];
    if(!y->leaf)
    {
        for(int j=1;j<=t;++j)z->c[j]=y->c[t+j];
    }
    y->n=t-1;
    for(int j=x->n;j>=i;--j)x->key[j+1]=x->key[j];
    x->key[i]=y->key[t];
    for(int j=x->n+1;j>=i+1;--j)x->c[j+1]=x->c[j];
    x->c[i+1]=z;
    ++x->n;
}

//x是一个非满结点
void BTreeInsertNonfull(node *x,char k)
{
    int i=x->n;
    if(x->leaf)   //x是叶结点
    {
        while(i>=1&&k<x->key[i])
        {
            x->key[i+1]=x->key[i];
            --i;
        }
        x->key[i+1]=k;
        ++x->n;
    }
    else   //x不是叶结点
    {
        while(i>=1&&k<x->key[i])--i;
        ++i;
        if(x->c[i]->n==2*t-1)   //x->c[i]是一个满结点 
        {
            BTreeSplitChild(x,i);
            if(k>x->key[i])++i;
        }
        BTreeInsertNonfull(x->c[i],k);
    }
}

void BTreeInsert(node *&root,char k)
{
    if(root->n==2*t-1)   //根节点是一个满结点
    {
        node *tmp=new node(0,false);
        tmp->c[1]=root;
        root=tmp;
        BTreeSplitChild(root,1);
    }
    BTreeInsertNonfull(root,k);
}

//x至少包含t个关键字，x->c[i]和x->c[i+1]都只包含t-1个关键字
void BTreeMergeChild(node *x,int i)
{
    node *y=x->c[i];
    node *z=x->c[i+1];
    y->key[y->n+1]=x->key[i];
    for(int j=1;j<=t-1;++j)y->key[y->n+1+j]=z->key[j];
    if(!z->leaf)
    {
        for(int j=1;j<=t;++j)y->c[y->n+1+j]=z->c[j];
    }
    y->n=2*t-1;
    for(int j=i+1;j<=x->n;++j)x->key[j-1]=x->key[j];
    for(int j=i+2;j<=x->n+1;++j)x->c[j-1]=x->c[j];
    --x->n;
    delete z;
}

//x至少包含t个关键字
void BTreeDeleteNonempty(node *x,char k)
{
    int i=1;
    while(k>x->key[i])++i;
    if(k==x->key[i])   //关键字k在结点x中
    {
        if(x->leaf)   //x是叶结点
        {
            for(int j=i+1;j<=x->n;++j)x->key[j-1]=x->key[j];
            --x->n;
        }
        else   //x是内部结点
        {
            if(x->c[i]->n>=t)   //x->c[i]至少包含t个关键字
            {
                //直接前驱
                node *p=x->c[i];
                while(!p->leaf)p=p->c[p->n+1];
                x->key[i]=p->key[p->n];
                BTreeDeleteNonempty(x->c[i],p->key[p->n]);
            }
            else if(x->c[i+1]->n>=t)   //x->c[i+1]至少包含t个关键字
            {
                //直接后继
                node *p=x->c[i+1];
                while(!p->leaf)p=p->c[1];
                x->key[i]=p->key[1];
                BTreeDeleteNonempty(x->c[i+1],p->key[1]);
            }
            else   //x->c[i]和x->c[i+1]都只包含t-1个关键字
            {
                BTreeMergeChild(x,i);
                BTreeDeleteNonempty(x->c[i],k);
            }
        }
    }
    else   //关键字k不在结点x中
    {
        if(x->c[i]->n==t-1)   //x->c[i]只包含t-1个关键字
        {
            if(i-1>=1&&x->c[i-1]->n>=t)   //相邻左兄弟至少包含t个关键字
            {
                //x中的关键字降至x->c[i]
                for(int j=x->c[i]->n;j>=1;--j)x->c[i]->key[j+1]=x->c[i]->key[j];
                x->c[i]->key[1]=x->key[i-1];
                //x->c[i-1]中的关键字升至x
                x->key[i-1]=x->c[i-1]->key[x->c[i-1]->n];
                if(!x->c[i-1]->leaf)
                {
                    for(int j=x->c[i]->n+1;j>=1;++j)x->c[i]->c[j+1]=x->c[i]->c[j];
                    x->c[i]->c[1]=x->c[i-1]->c[x->c[i-1]->n+1];
                }
                ++x->c[i]->n;
                --x->c[i-1]->n;
                BTreeDeleteNonempty(x->c[i],k);
            }
            else if(i+1<=x->n+1&&x->c[i+1]->n>=t)   //相邻右兄弟至少包含t个关键字
            {
                //x中的关键字降至x->c[i]
                x->c[i]->key[x->c[i]->n+1]=x->key[i];
                //x->c[i+1]中的关键字升至x
                x->key[i]=x->c[i+1]->key[1];
                for(int j=2;j<=x->c[i+1]->n;++j)x->c[i+1]->key[j-1]=x->c[i+1]->key[j];
                if(!x->c[i+1]->leaf)
                {
                    x->c[i]->c[x->c[i]->n+2]=x->c[i+1]->c[1];
                    for(int j=2;j<=x->c[i+1]->n+1;++j)x->c[i+1]->c[j-1]=x->c[i+1]->c[j];
                }
                ++x->c[i]->n;
                --x->c[i+1]->n;
                BTreeDeleteNonempty(x->c[i],k);
            }
            else   //相邻左右兄弟都只包含t-1个关键字      
            {
                if(i-1>=1)   //相邻左兄弟
                {
                    BTreeMergeChild(x,i-1);
                    BTreeDeleteNonempty(x->c[i-1],k);
                }
                else   //相邻右兄弟
                {
                    BTreeMergeChild(x,i);
                    BTreeDeleteNonempty(x->c[i],k);
                }
            }
        }
        else BTreeDeleteNonempty(x->c[i],k);   //x->c[i]至少包含t个关键字
    }
}

void BTreeDelete(node *&root,char k)
{
    if(root->n==1&&!root->leaf&&root->c[1]->n==t-1&&root->c[2]->n==t-1)   //case 2c或case 3b
    {
        BTreeMergeChild(root,1);
        node *tmp=root;
        root=root->c[1];
        delete tmp;
    }
    BTreeDeleteNonempty(root,k);
}

//             KQ
//       /     |      \ 
//      BF     M      TW
//   /  |  \  / \   / | \
//   A CDE H  L NP RS V XYZ

int main()
{
    node *root;
    BTreeCreate(root);
    string s="FSQKCLHTVWMRNPABXYDZE";
    for(int i=0;i<s.size();++i)BTreeInsert(root,s[i]);
    for(int i=0;i<s.size();++i)BTreeDelete(root,s[i]);
    return 0;
}

从B树、B+树、B*树谈到R 树：
http://blog.csdn.net/v_july_v/article/details/6530142

hz5034
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[算法导论] B树(B-tree) & B+树
心宝的博客
11-08 263
参考：从B树、B+树、B*树谈到R 树_结构之法 算法之道-CSDN博客_b树 参考：B-树的详解_William-CSDN博客_b-树 目录 B树(B-tree) B树的插入 B树的删除 B树(B-tree) B树是一种多路平衡查找树，它在文件系统中很有用。B树的结构有如下的特点： 一棵度为m的B树称为m阶B树。一个结点有k个孩子时，必有k-1个关键字才能将子树中所有关键字划分为k个子集。B树中所有结点的孩子结点最大值称为B树的阶，通常用m表示。从查找效率考虑，一般要求m≥3。树的高度包..
算法导论---B树
玩着玩着就完了的博客
04-27 273
B树 这是为磁盘存储而专门设计的一类平衡搜索树。由于磁盘访问相对访存极慢，因此度量B树的性能，考虑 a. 动态集合操作消耗的计算时间 b. 执行了多少次的磁盘存取。 对每个B树操作，磁盘存取的次数随着B树的高度增加。 B-tree定义 第1. 每个节点x有： a. x.n保存节点x的关键字个数。 b. x.n个关键字不严格...
【算法导论】B树
青峰碧陋室
12-04 2536
一棵B树T是具有如下性质的有根树（设根为root）: 1.每个节点x有一下域：（a）num,当前存储在节点x的关键字个数,关键字以非降序存放，因此key[i]                                                  （b）isleaf,是一个bool值，如果x为叶子节点，则isleaf=true.   （c）每个节点包括num+1个指向其子女的指针p
数据结构实践——B-树的基本操作
weixin_33834628的博客
11-29 446
本文是针对[数据结构基础系列(8)：查找]的实践。 【项目 - B-树的基本操作】 实现B-树的基本操作。基于序列{4, 9, 0, 1, 8, 6, 3, 5, 2, 7}完成测试。 （1）创建对应的3阶B-树b，用括号法输出b树。 （2）从b中分别删除关键字为8和1的节点，用括号法输出删除节点后的b树。 [参考解答] #...
数据结构树的基本操作_数据结构 二叉树 基本操作实例
weixin_30630377的博客
01-17 211
数据结构 二叉树 基本操作实例该程序分为五个文件：(1)BTree.h//// Created by Venus on 2016/10/24.//#ifndef BTREE_H#define BTREE_H#endifclass BTree {public:BTree* parent;BTree* leftChild;BTree* rightChild;int data;public:BTree(...
算法导论第十八章 B树
weixin_34239592的博客
05-11 266
一、高级数据结构 　　本章以后到第21章（并查集）隶属于高级数据结构的内容。前面还留了两章：贪心算法和摊还分析，打算后面再来补充。之前的章节讨论的支持动态数据集上的操作，如查找、插入、删除等都是基于简单的线性表、链表和树等结构，本章以后的部分在原来更高的层次上来讨论这些操作，更高的层次意味着更复杂的结构，但更低的时间复杂度（包括摊还时间）。 B树是为磁盘存储还专门设计的平衡查找树。因为磁盘...
算法导论 第18章 B树
幸福在路上
07-29 7624
一、定义 1、B树 B树是为磁盘或其它直接存取辅助存储设备而设计的一种平衡查找树，主要特点是降低磁盘I/O操作次数。 B树以自然的方式推广二叉查找树。 B树的分支因子由磁盘特性所决定。  2、B数的数据结构 int n：当前存储在结点x中的关键字数 key[N]：n个关键，以非降序存放 bool leaf;//TRUE:x是叶子；FALSE:x是内结点 node *child[N
《算法导论》第18章 B树
漂泊尘埃0x101010的专栏
09-02 647
1. B树的定义B树示意图：// 保存在B树中的关键字，同时也可以保存其他数据 type Key interface { CompareTo(other Key) int String() string }type BTree struct { root *BTreeNode t int // 最小度数，除根节点外的内部节点至少有t个孩子，至多2t个孩子 }ty
读书笔记：《算法导论》B树实现.zip
最新发布
07-25
读书笔记：《算法导论》B树实现
算法导论课后习题答案
04-08
7. **第9章：高级数据结构** - 这一章可能会介绍更复杂的数据结构，如红黑树、B树、Trie树等，以及与之相关的搜索和操作算法。 通过解决这些章节的课后习题，读者不仅可以深化对算法的理解，还能提升解决问题的能力...
算法导论第四版 英文
09-12
《算法导论第四版》涉及了如红黑树、B树、二叉搜索树、平衡查找树、哈希表、图的搜索算法（深度优先搜索和广度优先搜索）以及最小生成树、最短路径问题等高级主题。这部分内容为读者提供了处理更复杂数据结构和算法...
算法导论答案
04-08
第16章可能涉及查找算法，如二分查找、B树和B+树等。 9. **图论与网络流**：第24章可能涵盖图论的更多内容，如最大流问题和最小割问题，这是网络流理论的一部分。第25章可能涉及更复杂的算法，如网络简单路径和多源...
算法导论26（最大流）
Jiajun Zhu
11-07 3184
26.1流网络 26.2Ford-Fulkerson方法
算法导论20（van Emde Boas 树）
Jiajun Zhu
05-19 2549
#include<iostream> using namespace std;struct node { int u,min,max; node *summary; node **cluster; };void vEBTreeCreate(node *root,int u) { root->u=u; root->min=root->max=-1; if
算法导论25（所有结点对的最短路径问题）
Jiajun Zhu
10-30 2074
25.1最短路径和矩阵乘法
算法导论29（线性规划）
Jiajun Zhu
06-30 1957
29.1 标准型和松弛型标准型： maximize:∑j=1ncjxjsubjectto:∑j=1naijxj≤bi,i=1,2,⋯,mxj≥0,j=1,2,⋯,n\begin{array}{l} {\rm{maximize:}}\quad \sum\limits_{j = 1}^n {{c_j}{x_j}} \\ {\rm{subject}}\;{\rm{to:}}\quad \sum\limi
算法导论33（计算几何学）
Jiajun Zhu
05-21 1723
1.叉积 p1×p2=x1*y2-x2*y1=-p2×p12.确定连续线段是向左转还是向右转3.判断两条线段是否相交struct point { int x,y; };int direction(point pi,point pj,point pk) { //pkpi×pjpi return (pk.x-pi.x)*(pj.y-pi.y)-(pj.x-pi.x)*(pk.y
算法导论30（多项式与快速傅里叶变换）
Jiajun Zhu
06-29 1695
A(x)=a0+a1x+⋯+an−1xn−1=∑j=0n−1ajxj(a0+a1x+⋯+an−1xn−1)(b0+b1x+⋯+bn−1xn−1)=a0b0+(a0b1+a1b0)x+⋯+an−1bn−1x2n−2=∑j=02n−2(∑k=0jakbj−k)xj(aj=bj=0,j≥n)\begin{array}{*{20}{l}} {A(x) = {a_0} + {a_1}x + \cdots
算法导论28（矩阵运算）
Jiajun Zhu
06-26 1493
//Ax=b,PA=LU //LUx=Pb //Ly=pb,Ux=y vector<double> LUPSolve(vector<vector<double> > L,vector<vector<double> > U,vector<double> p,vector<double> b) { int n=L.size(); vector<double> x(n,0),y(n,0);
算法导论：数据结构篇--红黑树详解
与传统的平衡二叉搜索树如AVL树和B树相比，红黑树的实现更为简洁，且性能更稳定，比如Bayer在1972年提出的红黑树，其高度最多为2lg(n+1)，这比AVL树的1.44lg n更优。 红黑树的性质包括： 1. 所有节点颜色为红色或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值