B树 C++代码 总感觉哪里有问题，只供参考

最新推荐文章于 2019-03-14 13:14:59 发布
最新推荐文章于 2019-03-14 13:14:59 发布
阅读量231 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011274904/article/details/81386701
版权

#include<iostream>
using namespace std;

static const int MMM = 5;      //B树阶数
//static const int key_max = MMM + 1;      //key[0]不作用途， key[m]用于插入分裂时使用
#define DEFAULT 333
struct node
{
    int *key;      //关键码数组  [m/2-1]到[m-1],若m/2-1小于1，则关键码至少为1 
    //T *data;      //暂时不想考虑，其实data数组只要紧跟key数组就行
    node *parent;
    node **child;
    int key_num;      //当前关键码个数

    node() :key_num(0), parent(NULL), child(NULL)
    {
        key = new int[MMM + 1];
        key[0] = 0;
        child = new node*[MMM + 1];
        parent = NULL;
        for (int i = 0; i < MMM + 1; i++)
        {
            child[i] = NULL;
        }
    }
    ~node()      //用类对象表示节点时必须写，结构体应该可以不用谢
    {
        for (int i = 0; i < MMM + 1; i++)
        {
            delete child[i];
            child[i] = NULL;
        }
        delete key;
        delete child;
        child = NULL;
    }
};

class B_tree
{
private:
    node *b_root;
public:
    B_tree() :b_root(new node) {}
    ~B_tree() 
    {
        Destory(b_root);

        delete b_root->key;
        b_root->key = NULL;
        b_root->parent = NULL;
        for (int i = 0; i < b_root->key_num; i++)
        {
            delete b_root->child[i];
            b_root->child[i] = NULL;
        }
        b_root = NULL;
    };

    void Insert(const int k);      //往B树中插入节点   只要考虑最大子树个数，删除是才要考虑【m/2】这个最小子树个数
    node* Search(node *root, const int k);      //在B树中寻找关键码值为k的关键码,并返回所在的节点
    node* Split(node* &root, const int index);      //插入节点后向上分裂   返回值类型任意
    node* Root();      //获取根节点
    void Level_order();      //层序遍历B树
    void Adjust(node *root);      //调整B树
    bool Remove(const int k);      //删除内部节点，用后继节点节点代替，即复制删除
    void Destory(node *root);      //销毁B树
};


inline node* B_tree::Root()
{
    return b_root;
}

node* B_tree::Search(node *root, const int k)
{
    if (root->key_num == 0)
    {
        cout << "B树为空，查找失败!" << endl;
        return NULL;
    }
    while (root->child[0] != 0)
    {
        for (int i = root->key_num; i >= 0;  i--)
        {
            if (root->key[i] == k)
            {
                cout << "关键码值 " << k << " 是B树的关键码!" << endl;
                return root;
            }
            if (root->key[i] < k)
            {
                root = root->child[i];
                break;
            }
        }
    }
    for (int i = 1; i <= root->key_num; i++)
    {
        if (root->key[i] == k)
        {
            cout << "关键码值 " << k << " 是B树的关键码!" << endl;
            return root;
        }
    }
    cout << "关键码值 " << k << " 不是B树的关键码!" << endl;
    return NULL;
}

void B_tree::Insert(const int k)      //往B树中插入节点   只要考虑最大子树个数，删除是才要考虑【m/2】这个最小子树个数
{
    node *root = b_root;
    for (int m = 1; m <= root->key_num; m++)
    {
        cout << "[" << root->key[m] << "]";
    }
    cout << endl;
    if (root->child[0] == NULL && root->key_num == 0)
    {
        root->key_num++;
        root->key[1] = k;
        root->parent = NULL;
        return;
    }
    int i, j;
    while (root->child[0] != NULL)
    {
        for (i = root->key_num; i >= 0; i--)
        {
            if (root->key[i] == k)
            {
                cout << "关键码值 " << k << " 已经是B树的关键码!" << endl;
                return;
            }
            if (root->key[i] < k)
            {
                root = root->child[i];
                break;
            }
        }
    }
    for (i = root->key_num; i >= 0; i--)
    {
        if (root->key[i] == k)
        {
            cout << "B树中已经有 " << k << " 这个关键码" << endl;
            return;
        }
        if (root->key[i] < k)
        {
            for (j = root->key_num; j > i; j--)
            {
                root->key[j + 1] = root->key[j];
            }
            root->key[i + 1] = k;
            root->key_num++;
            break;
        }
    }
    while (root->key_num == MMM)
    {
        Split(root, (1 + MMM) / 2);
    }
}

node* B_tree::Split(node* &root, int index)      //root节点是待分裂节点
{
    int i, j;
    int k = root->key[index];
    node *other = new node;      //root节点分裂后的另一半
    for (i = index + 1; i <= root->key_num; i++)
    {
        other->key[i - index] = root->key[i];
        other->key_num++;
    }
    if (root->child[0] != NULL)       //分裂节点为内部节点
    {
        
        for (i = index; i <= root->key_num; i++)
        {
            other->child[i - index] = root->child[i];      //分裂内部节点时，孩子比关键码要多一个
            root->child[i]->parent = other;      //这个是重中之重， 移动分裂孩子节点其父节点必须一并修改
            //delete root->child[i];      //删除后，空间释放，会出问题，指针置空就行  类可以，结构体删除即释放
            root->child[i] = NULL;
        }
    }
    root->key_num = index - 1;
    if (root->parent == NULL)
    {
        node *r = new node;      //新根节点，树的高度会增加
        r->key_num++;
        r->key[1] = k;
        r->child[0] = root;
        r->child[1] = other;
        r->parent = NULL;
        other->parent = r;
        root->parent = r;
        b_root = r;
        return b_root;
    }
    else
    {
        node *p = root->parent;
        for (i = p->key_num; i >= 0; i--)
        {
            if (p->key[i] < k)
            {
                break;
            }
        }
        for (j = p->key_num; j > i; j--)
        {
            p->key[j + 1] = p->key[j];
            p->child[j + 1] = p->child[j];
        }
        p->key_num++;
        p->key[i + 1] = k;
        p->child[i + 1] = other;
        //p->child[i] = root;      //注意下就行
        other->parent = p;
        root = p;
        return root;
    }
}

void B_tree::Level_order()      //层序遍历B树
{
    if (b_root == NULL)
    {
        cout << "B树为空，层序遍历失败!" << endl;
        return;
    }
    node **qu = new node*[DEFAULT];
    int front = 0;
    int rear = 0;
    qu[front] = qu[rear++] = b_root;
    int max = DEFAULT;      //假设循环空间足够大，要不然还得判断是不是装满了
    int counter = 0;
    cout << "B树的层序遍历为:{";
    while (front != rear)
    {
        node *p = qu[front];
        front = (front + 1) % max;
        if (counter = 1)
        {
            cout << "[";
            for (int i = 1; i <= p->key_num; i++)
            {
                cout << " " << p->key[i] << " ";
            }
            cout << "]";
        }
        //cout << endl;
        if (p->child[0] != NULL)
        {
            for (int j = 0; j <= p->key_num; j++)
            {
                qu[rear] = p->child[j];
                rear = (rear + 1) % max;
            }
        }
        counter++;
    }
    cout << "}";
    
}

bool B_tree::Remove(const int k)
{
    node *root = b_root;
    root = Search(root, k);
    if (root == NULL)
    {
        cout << "B树中不存在关键码值为 " << k << " 的关键码!" << endl;
        return false;
    }
    int i, index;
    for (i = 1; i <= root->key_num; i++)      //确定k所在的节点
    {
        if (root->key[i] == k)
        {
            index = i;      //k为其所在节点第i个元素
            break;
        }
    }
    if (root->child[0] == NULL)      //被删除的关键码在叶节点上
    {
        for (i = index; i < root->key_num; i++)      //在节点中删除k，并移动关键码数组
        {
            root->key[i] = root->key[i + 1];
        }
        root->key_num--; 
        if (root->parent == NULL)      //只有根节点
        {
            if (root->key_num == 0)      //根节点没有关键码，B树为空     
            {
                root = NULL;
            }
            return true;
        }
        if (root->key_num >= (MMM - 1) / 2)      //删除k后的节点关键码的个数比最少大，直接返回
        {
            return true;
        }
        else
        {
            Adjust(root);      //调整B树
        }
    }
    if (root->child[0] != NULL)      //如果k在内部节点中，先把其与其后继最小的交换，然后相当于删除叶节点         
    {
        node *curr = root->child[index];
        while (curr->child[0] != NULL)      //直到找到k节点后继中的最小值，然后复制删除
        {
            curr = curr->child[0];
        }
        root->key[index] = curr->key[1];      //复制删除
        curr->key[1] = k;
        for (i = 1; i < curr->key_num; i++)
        {
            curr->key[i] = curr->key[i + 1];
        }
        curr->key_num--;
        if (curr->key_num >= (MMM - 1) / 2)
        {
            return true;
        }
        else
        {
            Adjust(curr);
        }
    }
    return true;
}

void B_tree::Adjust(node *root)
{
    if (root->parent == NULL)
    {
        return;
    }
    int i, index;
    node *p = root->parent;
    for (i = 0; i <= p->key_num; i++)      //确定root节点在父节点孩子节点指针数组中的位置
    {
        if (p->child[i] == root)
        {
            index = i;
            break;
        }
    }
    cout << index << endl;
    
    if (index == 0)      //防止越界，不写这个判定条件跟右边借总会出问题，非得这样坑我
    {
        if (p->child[index + 1] != NULL && p->child[index + 1]->key_num > (MMM - 1) / 2)      //右兄弟
        {
            node *right = p->child[index + 1];
            root->key_num++;
            root->key[root->key_num] = p->key[index + 1];
            p->key[index + 1] = right->key[1];
            for (i = 1; i < right->key_num; i++)
            {
                right->key[i] = right->key[i + 1];
            }
            if (root->child[0] != NULL)      //root不为叶子节点
            {
                root->child[root->key_num] = right->child[0];
                right->child[0]->parent = root;
                for (i = 0; i < right->key_num; i++)
                {
                    right->child[i] = right->child[i + 1];
                }
                right->child[right->key_num] = NULL;
            }
            right->key_num--;
            return;
        }
        if (p->child[index + 1] != NULL && p->child[index + 1]->key_num == (MMM - 1) / 2)
    {
        node *right = p->child[index + 1];
        root->key_num++;
        root->key[root->key_num] = p->key[index + 1];
        if (root->child[0] != NULL)
        {
            int mmm = root->key_num;
            for (i = 0; i <= right->key_num; i++)
            {
                root->child[mmm++] = right->child[i];
                right->child[i]->parent = root;
            }
        }
        for (i = 1; i <= right->key_num; i++)
        {
            root->key_num++;
            root->key[root->key_num] = right->key[i];
        }
        for (i = index + 1; i < p->key_num; i++)
        {
            p->child[i] = p->child[i + 1];
            p->key[i] = p->key[i + 1];
        }
        p->child[p->key_num] = NULL;
        p->key_num--;
        delete right;
        right = NULL;
        if (p == b_root && p->key_num == 0)
        {
            p = NULL;
            b_root = root;
            root->parent = NULL;
            return;
        }
        if (p->key_num < (MMM - 1) / 2)
        {
            Adjust(p);
        }
    }
    }
    if (index > 0 && index <= p->key_num)
    {
        if (p->child[index - 1] != NULL && p->child[index - 1]->key_num > (MMM - 1) / 2)      //左兄弟
        {
            node *left = p->child[index - 1];
            for (i = root->key_num; i >= 1; i--)
            {
                root->key[i + 1] = root->key[i];
            }
            root->key[1] = p->key[index];
            p->key[index] = left->key[left->key_num];
            if (root->child[0] != NULL)
            {
                for (i = root->key_num; i >= 0; i--)
                {
                    root->child[i + 1] = root->child[i];
                }
                root->child[0] = left->child[left->key_num];
                left->child[left->key_num]->parent = root;
                left->child[left->key_num] = NULL;
            }
            root->key_num++;
            left->key_num--;
            return;
        }
        if (p->child[index - 1] != NULL && p->child[index - 1]->key_num == (MMM - 1) / 2)
        {
            node *left = p->child[index - 1];
            left->key_num++;
            left->key[left->key_num] = p->key[index];
            if (root->child[0] != NULL)
            {
                int mmm = left->key_num;
                for (i = 0; i <= root->key_num; i++)
                {
                    left->child[mmm++] = root->child[i];
                    root->child[i]->parent = left;
                }
            }
            for (i = 1; i <= root->key_num; i++)
            {
                left->key_num++;
                left->key[left->key_num] = root->key[i];
            }
            for (i = index; i < p->key_num; i++)
            {
                p->child[i] = p->child[i + 1];
                p->key[i] = p->key[i + 1];
            }
            p->child[p->key_num] = NULL;
            p->key_num--;
            root = NULL;
            if (p == b_root && b_root->key_num == 0)
            {
                p = NULL;
                b_root = left;
                left->parent = NULL;
                return;
            }
            if (p->key_num < (MMM - 1) / 2)
            {
                Adjust(p);
            }
        }
    }
    
}

void B_tree::Destory(node *root)
{
    if (root->child[0] == NULL && root->key_num != 0)
    {
        delete root->key;
        root->key = NULL;
        root->parent = NULL;
        for (int i = 0; i < root->key_num; i++)
        {
            delete root->child[i];
            root->child[i] = NULL;
        }
        delete root;
        root = NULL;
        return;
    }
    if (root->child[0] != NULL)
    {
        for (int i = 0; i <= root->key_num; i++)
        {
                Destory(root->child[i]);
        }
    }
}

void main()
{
    B_tree tree;
    node *root = new node;
    int arr[22] = { 39,22,97,41,53,13,21,40,30,27,33,36,35,34,24,29,26,23,17,28,31,32 };
    for (int i = 0; i < 22; i++)
    {
        tree.Insert(arr[i]);
    }
    root = tree.Root();
    tree.Search(root, 35);
    tree.Level_order();
    cout << endl;
    tree.Remove(13);
    tree.Level_order();
    cout << endl;
    tree.Remove(27);
    tree.Level_order();
    cout << endl;
    tree.Remove(32);
    tree.Level_order();
    cout << endl;
    tree.Remove(40);
    tree.Level_order();
    cout << endl;
    tree.Remove(17);
    tree.Level_order();
    cout << endl;
    tree.Remove(34);
    tree.Level_order();
    cout << endl;
    tree.Remove(22);
    tree.Level_order();
    cout << endl;
    tree.Remove(23);
    tree.Level_order();
    cout << endl;
    tree.Remove(21);
    tree.Level_order();
    cout << endl;
    tree.Remove(24);
    tree.Level_order();
    cout << endl;
    tree.Remove(36);
    tree.Level_order();
    cout << endl;
    tree.Remove(39);
    tree.Level_order();
    cout << endl;
    tree.Remove(31);
    tree.Level_order();
    cout << endl;
    tree.Remove(33);
    tree.Level_order();
    cout << endl;
    tree.Remove(28);
    tree.Level_order();
    cout << endl;
    tree.Remove(97);
    tree.Level_order();
    cout << endl;
    tree.Remove(53);
    tree.Level_order();
    cout << endl;
    tree.Remove(41);
    tree.Level_order();
    cout << endl;
    tree.Remove(26);
    tree.Remove(29);
    tree.Remove(30);
    tree.Remove(35);
    tree.Level_order();
    cout << endl;
    //tree.Destory(tree.Root());
    tree.Level_order();
}

一梦花开
关注
【C++软件调试技术】C++软件开发维护过程中典型软件异常问题的排查与总结
dvlinker的技术专栏
04-15 8万+
本文以问答的方式进行展开，罗列了C++软件日常开发和维护中遇到的多个软件调试问题及有代表性的场景，给出详细的处置思路和处理办法，以供大家借鉴和参考。
数据结构实验B树的C++代码实现
qq965194745的博客
10-23 5623
采用整数为顶点值和多叉链表为存储结构，实现抽象数据类型B树。ADT BTNode{ 数据对象：D是具有相同特性的数据元素的集合，称为节点集。 数据关系： 若D为空集，则称为空树； （1）树中每个结点最多含有m棵子树； （2）若根结点不是叶子结点，则至少有2个子树； （3）除根结点之外的所有非终端结点至少有┌m/2┐棵子树； （4）每个非终端结点中包含信息：（n，A0，K
B树的实现（C++）
07-16
网上很多程序没有注释，代码运行报错。所以精心重写了一下B树的实现。程序结构严谨，有详细的注释，运行没有问题，基于vs2013平台。对于刚学算法的人应该会有很大帮助。
Btree(B-树)---C++
weixin_34413065的博客
05-07 161
一棵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树的c++实现
andefine的博客
11-17 886
算法导论的课要完成一个小课题，选了B树，花了挺长时间弄完，之前写了几个简单的排序，发现这递归是真的牛批啊。代码部分参考了这位博主。在写前面的插入那一大块，书上有伪代码可以对着写。但是后面的删除部分没有伪代码，懵了好久，找到另一位博主写的伪代码，有几处小错误，我重新写了一遍，并加上了注释（自己理解的注释，可能有地方理解有误）。不多bb，直接上伪代码和最终源码 // 伪代码均以书上的标准
B-树的C++实现
BlueDog专栏
05-04 3806
发布一个B-树的代码 代码下载:http://bluedog.download.csdn.net B-<span style="font-family:宋体;mso-ascii-font-family:">树网上的代码很象不是很多，关于它的原理我觉得没有必要要谈了，书上网上太多了。这里我花了几天的时间写了一个，大家觉得有用的话就用吧，已经进行大量的测试，应该没有什么太大问题
B 树C++实现
疯蝴蝶的JAVA世界
05-02 653
1.  实现过程参考 第18章B树 /*  * b_tree.h  *  *  Created on: 2011-11-10  *      Author: guopeng  */ #ifndef B_TREE_H_ #define B_TREE_H_ #include #include #include #include "circle_queue.
C++大作业基于B树的GUI图书管理系统+源代码+文档说明
01-10
C++大作业基于B树的GUI图书管理系统+源代码+文档说明 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ ...
C++项目源代码（适合新手练手及参考）
11-29
【标题】"C++项目源代码（适合新手练手及参考）" 提供了一套针对初学者的C++编程实践项目，旨在帮助新手通过实际操作来理解和掌握C++语言。这个项目不仅包含了源代码，还提供了详细的注释，使得学习过程更加直观易懂...
基于QT+C++实现B树可视化+源码+项目文档+效果展示（毕业设计&课程设计&项目开发）
最新发布
08-29
基于QT+C++实现B树可视化+源码+项目文档+效果展示，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用，详情见md文档~ 基于QT+C++实现B树可视化+源码+项目文档+效果...
C++ 数据结构 算法B+树实现
04-22
C++ 数据结构 算法B+树 实现。 实现了 B+树的初始化 插入 遍历 删除
B树算法的C++实现
10-24
B树算法的C++实现，B树算法的C++实现，B树算法的C++实现，B树算法的C++实现
B+树C++代码实现
01-01
一个外国人写的B+树算法，由于注释比较少，故个人在参照时加上了自己的注释。该代码还用带了LRR和折半查找技术，很值得参考学习！！
B树、B+树的C++实现
07-05
B树、B+树的C++实现
B-树 C实现完整测试源码
01-09
该代码是根据算法导论中B树的性质，设计方法编写的功能完善的c代码，内带注释，比较容易看懂，并在此基础上编写自己的小型数据库。
【算法学习】B-Tree编程实现（C++模板类封装）
计算机专业同学的充电站。
03-20 3984
B-Tree模拟编程实现。采用C++模板类封装。参考《算法导论（第二版）》第18章 B树。 实现了B树的搜索、插入和删除的重要操作。 欢迎交流和讨论，如有错误，还请指出~（E-Mali：xiajunhust@gmail.com） BTree.h： //B-树编程实现 //《算法导论（第二版）》第18章 B树 //Author：江南烟雨 //E-Mail：xiaj
B树插入删除实现（c++）
虹少侠的博客
03-14 1225
B树的性质 1、树的每个节点最多有M个子树。 2、根节点至少有两个子树（除非它是叶子节点）。 3、除根节点之外的所有非叶子节点至少有M/2个子树（向上取整）。 4、所有非叶子节点包含keycount, childs[0],keys[1],childs[1],keys[2]........keys[keycount],childs[keycount]。 也就是所有非叶子节点的子树在key值...
B树的C++实现
wzh_xwjh的专栏
10-30 1006
最近写一个程序需要用到 B 树，翻书看了下，参照网上的代码写了一个。对于 B 树的定义和生成有不少的文章讲过，我就不多废话，直接贴代码。 　　这里面主要包含两个类，CBTree 和 CDataTypeForBtree，其余几个是测试用的。B 树的实现类 CBTree 里面，关键字实际保存的是地址，虽然也可以保存无符号整数，但显然这不是我的初衷，我想让这一个 B 树类能够处理不同类型的数据
【数据结构】树（四）：B树（C++实现）
快去创造奇迹
04-22 1511
B树
QT+C++ B树可视化项目：源码、文档及展示
资源摘要信息:"本项目为基于QT和...文件名称列表中仅有一个"QT实现B树可视化"，表明该压缩包内可能只包含一个主要项目文件或程序。用户可以根据此名称快速定位到所需的项目文件，从而开始项目的编译、运行和开发工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值