B+树简单实现(PHP)

最新推荐文章于 2024-05-02 07:35:58 发布
最新推荐文章于 2024-05-02 07:35:58 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： PHP Algorithms DB 文章标签： B+树 B-Tree mysql索引 B树实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aikiller/article/details/82389194
版权
PHP 同时被 3 个专栏收录
59 篇文章 0 订阅
订阅专栏
Algorithms
15 篇文章 0 订阅
订阅专栏
DB
5 篇文章 0 订阅
订阅专栏

GitHub源码
原理参考此链接
下面是一些实现细节

  1. 注意

    • 叶节点包含所有的索引和数据
    • 只有叶节点才会持有具体数据,非叶节点只有索引
    • 叶节点之间连接成一个链表,便于范围查询

  2. 树节点结构

     BTNode {
      id : 标识节点对象的唯一值
      parent : 父节点的ID值
      isLeaf : 是否是叶节点
      indexNum : 当前索引的数量,一旦该值超过树的阶,该节点就需要分裂
      indexMap : 索引对象列表
      next : 下一个兄弟节点的ID值(该属性仅针对叶子节点)
     }

  1. insert[插入]过程(将值写入叶节点中,叶节点的分裂可能会造成非叶节点的分裂)

    • 叶子节点中保存具体的值.
    • 树为空,直接创建一个根节点,此节点是叶节点.
    • 定位需要插入的叶节点时, 需要处理的下一个树节点是该节点中第一个大于要写入索引值索引对象的上一个兄弟索引对象指向的树节点
    • 树中已经存在相同的索引,不做处理.
    • 当叶子节点索引对象达到上限后,需要分裂该叶节点

  2. split[分裂]过程

    • 节点分裂会分裂出两个,一个是去掉中间索引及之后索引的原节点,另一个是新创建的节点,该节点中包含原节点中间索引及之后索引
    • 分裂节点为根节点时,树高度+1,创建新节点作为根节点.
    • 新树节点的父节点是原节点的父节点,若原节点是根节点,则新树节点的父节点是新的根节点.
    • 索引指向子节点的原始父节点是分裂之前的原节点,现在更改为它们移动到的新节点.
    • 原节点的父节点更新为新的父节点(原节点为根节点时,会重新创建根节点,此时原节点的父节点是这个新的根节点).
    • 原节点分裂后,中间索引及之后的索引都被移动到了新节点,所以把移动的索引在原节点中删除.
    • B+树的叶子节点之间形成一个链表,在原节点分裂后,原节点的next指向新节点,新节点的next指向原节点的next.
    • 向分裂节点的父节点添加索引对象,该索引对象的索引值是分裂节点的中间索引值,指向的是新创建的树节点.
    • 若分裂节点的父节点索引达到上限,需要分裂父节点.
      5.find[单条查询]过程
    • 需要注意的是,只有叶节点中索引值相同的索引对象才持有具体数据.
      6.rangeFind[范围查询]过程
    • 根据start索引,定位到叶节点链表开始的节点.
    • 从定位到的节点,遍历叶节点链表,查询出范围内的记录
      7.delete[单条删除]过程
    • 待实现
<?php
/**
 * Class Data
 *
 * 数据类
 */
class Data
{
    private $data = [];

    private $indexKey;

    public function __construct(array $data, $indexKey = 'index')
    {
        $this->data = $data;
        $this->indexKey = $indexKey;
    }

    public function getIndex()
    {
        return isset($this->data[$this->indexKey]) ? $this->data[$this->indexKey] : 0;
    }

    public function __toString()
    {
        return json_encode($this->data);
    }
}

/**
 * Class Index
 *
 * 索引对象
 */
class Index
{
    /**
     * @var int
     *
     * 索引值
     */
    private $index;

    /**
     * @var Data
     *
     * 索引指向的具体数据,在叶节点中该属性才有值
     */
    private $data;

    /**
     * @var int
     *
     * 索引指向的BTNode的ID
     */
    private $next;

    public function __construct($index = 0, $next = 0, Data $data = null)
    {
        $this->index = $index;
        $this->next = $next;
        $this->data = $data;
    }

    public function getIndex()
    {
        return $this->index;
    }

    public function getNext()
    {
        return $this->next;
    }

    /**
     * @return Data
     */
    public function getData()
    {
        return $this->data;
    }
}

/**
 * Class IndexMapIterator
 *
 * BTNode的indexMap的迭代器
 */
class IndexMapIterator implements Iterator
{
    private $indexMap = [];
    private $position = 0;

    public function __construct($indexMap = [])
    {
        $this->indexMap = $indexMap;
        $this->position = 0;
    }

    /**
     * @return Index
     */
    public function current()
    {
        return $this->indexMap[$this->position];
    }

    public function next()
    {
        $this->position++;
    }

    public function prev()
    {
        $this->position--;
    }

    public function key()
    {
        return $this->position;
    }

    public function valid()
    {
        return isset($this->indexMap[$this->position]);
    }

    public function rewind()
    {
        $this->position = 0;
    }

}

/**
 * Class BTNode
 *
 * B+树节点
 */
class BTNode
{
    /**
     * @var int
     *
     * 标识节点对象的唯一值
     */
    private $id = 0;

    /**
     * @var int
     *
     * 父节点的ID值
     */
    public $parent = 0;

    /**
     * @var bool
     *
     * 是否是叶节点
     */
    public $isLeaf = false;

    /**
     * @var int
     *
     * 当前索引的数量,一旦该值超过树的阶,该节点就需要分裂
     */
    public $indexNum = 0;

    /**
     * @var array
     *
     * 索引对象列表
     */
    private $indexMap = [];

    /**
     * @var int
     *
     * 下一个兄弟节点的ID值(该属性仅针对叶子节点)
     */
    public $next = 0;

    public function __construct($isLeaf = false, $parent = 0)
    {
        $this->init($isLeaf, $parent);
    }

    protected function init($isLeaf, $parent)
    {
        $this->id = uniqid();
        $this->isLeaf = $isLeaf;
        $this->parent = $parent;
        $this->indexMap = [];
    }

    public function getID()
    {
        return $this->id;
    }

    /**
     * @param Index $index
     *
     * 向树节点中添加新的索引对象,添加完成后需要按索引值升序排序
     */
    public function addIndex(Index $index)
    {
        array_push($this->indexMap, $index);
        usort($this->indexMap, function (Index $a, Index $b) {
            if ($a->getIndex() == $b->getIndex()) {
                return 0;
            }
           return $a->getIndex() > $b->getIndex() ? 1 : -1;
        });
        $this->indexNum++;
    }

    /**
     * @return IndexMapIterator
     *
     * 生成indexMap的迭代器
     */
    public function generateIndexMapIterator()
    {
        return new IndexMapIterator($this->indexMap);
    }

    /**
     * @param $order
     * @return bool
     *
     * 判断该节点是否已满,当前的索引对象树超过树的阶即为满.
     */
    public function isFull($order)
    {
        return $this->indexNum > $order;
    }

    public function deleteMap($start)
    {
        $count = 0;
        for ($i = $start; $i < $this->indexNum; $i++) {
            $count++;
            unset($this->indexMap[$i]);
        }

        $this->indexNum = $this->indexNum - $count;
    }

    public function updateParent($id)
    {
        $this->parent = $id;
    }

    public function setNext($id)
    {
        $this->next = $id;
    }
}

/**
 * Class BPlusTree
 *
 * B+树
 */
class BPlusTree
{
    /**
     * @var int
     *
     * 根节点ID
     */
    public $root = 0;

    /**
     * @var array
     * 节点池: 节点的id为key, 节点对象为value
     */
    private $nodeMap = [];

    /**
     * @var int
     *
     * B+树的阶
     */
    private $order;

    public function __construct($order = 3)
    {
        $this->order = $order;
    }

    /**
     * @param Data $record
     *
     * 写入数据
     */
    public function insert(Data $record)
    {
        $index = $record->getIndex();

        if ($this->isEmpty()) {
            //树为空,直接创建一个根节点,此节点是叶节点.
            $node = new BTNode( true,0);
            $node->addIndex(new Index(0, 0));
            $node->addIndex(new Index($index, 0, $record));
            $this->storeNode($node);
            $this->root = $node->getID();
        } else {
            $tmpNode = $this->getNodeByID($this->root);
            $prevNode = $tmpNode;

            //定位需要插入的叶节点
            while ($tmpNode != null) {
                $prevNode = $tmpNode;
                $indexMapIterator = $tmpNode->generateIndexMapIterator();

                //需要处理的下一个树节点是该节点中第一个大于要写入索引值索引对象的上一个兄弟索引对象指向的树节点
                while ($indexMapIterator->valid()) {
                    $indexObj = $indexMapIterator->current();

                    if ($index > $indexObj->getIndex()) {
                        $indexMapIterator->next();
                    } else if ($index == $indexObj->getIndex()) {
                        //树中已经存在相同的索引,不做处理.
                        return false;
                    } else {
                        break;
                    }
                }

                $indexMapIterator->prev();
                $currentIndex = $indexMapIterator->current();
                $tmpNode = $this->getNodeByID($currentIndex->getNext());
            }

            //叶子节点中保存具体的值.
            $prevNode->addIndex(new Index($index, 0, $record));


            //树节点需要分裂
            if ($prevNode->isFull($this->order)) {
                $this->split($prevNode);
            }
        }
    }

    /**
     * @param BTNode $node
     *
     * 分裂节点
     *
     */
    protected function split(BTNode $node)
    {
        //获取中间索引,创建新的索引
        $middle = intval(ceil($node->indexNum/2));
        $middleIndexValue = 0;

        $pid = $node->parent;

        //分裂节点为根节点时,树高度+1,创建新节点作为根节点.
        if ($pid == 0) {
            $parent = new BTNode(false, 0);
            $this->storeNode($parent);
            $parent->addIndex(new Index(0, $node->getID()));
            $pid = $parent->getID();

            //新节点作为根节点
            $this->root = $pid;
        }
        $parent = $this->getNodeByID($pid);

        //新树节点的父节点是原节点的父节点,若原节点是根节点,则新树节点的父节点是新的根节点.
        $newNode = new BTNode($node->isLeaf, $pid);
        $this->storeNode($newNode);

        $indexMapIterator = $node->generateIndexMapIterator();
        while ($indexMapIterator->valid()) {

            //将中间索引及之后的索引,移动到新节点
            if ($indexMapIterator->key() >= $middle) {
                $indexObj = $indexMapIterator->current();
                $newNode->addIndex(new Index($indexObj->getIndex(), $indexObj->getNext(), $indexObj->getData()));
                $tmp = $this->getNodeByID($indexObj->getNext());
                //索引指向子节点的原始父节点是分裂之前的节点,现在更改为它们移动到的新节点
                if ($tmp != null) {
                    $tmp->updateParent($newNode->getID());
                }
                if ($indexMapIterator->key() == $middle) {
                    $middleIndexValue = $indexObj->getIndex();
                }
            }
            $indexMapIterator->next();
        }

        //原节点的父节点更新为新的父节点(原节点为根节点时,会重新创建根节点,此时原节点的父节点是这个新的根节点)
        $node->updateParent($pid);

        //原节点分裂后,中间索引及之后的索引都被移动到了新节点,所以把移动的索引在原节点中删除
        $node->deleteMap($middle);

        //B+树的叶子节点之间形成一个链表,在原节点分裂后,原节点的next指向新节点,新节点的next指向原节点的next
        if ($node->isLeaf) {
            $newNode->setNext($node->next);
            $node->setNext($newNode->getID());
        }

        //向分裂节点的父节点添加索引对象,该索引对象的索引值是分裂节点的中间索引值,指向的是新创建的树节点
        $parent->addIndex(new Index($middleIndexValue, $newNode->getID()));

        //若分裂节点的父节点索引达到上限,需要分裂父节点
        if ($parent->isFull($this->order)) {
            $this->split($parent);
        }
    }

    /**
     * @param $index
     * @return Data|string
     *
     * 索引单条查询
     */
    public function find($index)
    {
        $tmpNode = $this->getNodeByID($this->root);
        while ($tmpNode != null) {
            $indexMapIterator = $tmpNode->generateIndexMapIterator();
            while ($indexMapIterator->valid()) {
                $indexObj = $indexMapIterator->current();
                if ($index > $indexObj->getIndex()) {
                    $indexMapIterator->next();
                } else if ($index == $indexObj->getIndex()) {
                    //只有叶节点中索引值相同的索引对象才持有具体数据.
                    if ($tmpNode->isLeaf) {
                        return $indexObj->getData();
                    } else {
                        $indexMapIterator->next();
                    }
                } else {
                    break;
                }
            }
            $indexMapIterator->prev();
            $tmpNode = $this->getNodeByID($indexMapIterator->current()->getNext());
        }

        return 'record ['.$index. '] is not exists!';
    }

    public function delete()
    {
        //TODO
    }

    /**
     * @param $start
     * @param $end
     * @return array
     *
     * 范围查询
     */
    public function rangeFind($start, $end)
    {
        $index = $start;

        $tmpNode = $this->getNodeByID($this->root);
        $prevNode = $tmpNode;

        //根据start索引,定位到叶节点链表开始的节点.
        while ($tmpNode != null) {
            $prevNode = $tmpNode;
            $indexMapIterator = $tmpNode->generateIndexMapIterator();
            while ($indexMapIterator->valid()) {
                $indexObj = $indexMapIterator->current();
                if ($index >= $indexObj->getIndex()) {
                    $indexMapIterator->next();
                } else {
                    break;
                }
            }
            $indexMapIterator->prev();
            $tmpNode = $this->getNodeByID($indexMapIterator->current()->getNext());
        }

        $tNode = $prevNode;
        $resultData  = [];

        //从定位到的节点,遍历叶节点链表,查询出范围内的记录
        while ($tNode != null) {
            $indexMapIterator = $tNode->generateIndexMapIterator();
            while ($indexMapIterator->valid()) {
                $indexObj = $indexMapIterator->current();
                if ($indexObj->getIndex() > $end) {
                    break 2;
                }
                if ($indexObj->getIndex() >= $start) {
                    array_push($resultData, $indexObj->getData());
                }
                $indexMapIterator->next();
            }
            $tNode = $this->getNodeByID($tNode->next);
        }

        return $resultData;
    }

    public function isEmpty()
    {
        return $this->root === 0;
    }

    /**
     * @param BTNode $node
     *
     * 以节点的id为key, 节点对象为value, 保存到节点池中.
     */
    private function storeNode(BTNode $node)
    {
        $id = $node->getID();
        $this->nodeMap[$id] = $node;
    }

    /**
     * @param $id
     * @return BTNode
     */
    public function getNodeByID($id)
    {
        return isset($this->nodeMap[$id]) ? $this->nodeMap[$id] : null;
    }

    /**
     * @param bool $onlyLeafNode
     *
     * 打印所有节点
     */
    public function dumpNodeMap($onlyLeafNode = false)
    {
        echo '<pre>';
        foreach ($this->nodeMap as $eachNode) {
            if (!$onlyLeafNode || $eachNode->isLeaf) {
                var_dump($eachNode);
            }
        }
    }
}

/******************************************** 测试代码 ******************************************************/

$dataList = [
    ['index' => 10, 'name' => 'name_10'],
    ['index' => 20, 'name' => 'name_20'],
    ['index' => 30, 'name' => 'name_30'],
    ['index' => 40, 'name' => 'name_40'],
    ['index' => 5, 'name' => 'name_5'],
    ['index' => 15, 'name' => 'name_15'],
    ['index' => 50, 'name' => 'name_50'],
    ['index' => 35, 'name' => 'name_35'],
    ['index' => 60, 'name' => 'name_60'],
    ['index' => 45, 'name' => 'name_45'],
    ['index' => 22, 'name' => 'name_22'],
];

$testList = [50, 100, 45, 16];

$btree = new BPlusTree(3);

foreach ($dataList as $value) {
    $data = new Data($value);
    $btree->insert($data);
}

//$btree->dumpNodeMap();
//$btree->dumpNodeMap(true);

echo '单条查询 : <br>';
foreach ($testList as $eachIndex) {
    echo $btree->find($eachIndex).'<br>';
}
echo '<hr>';
echo '范围查询 : <br>';

foreach ($btree->rangeFind(4, 33) as $eachData) {
    echo $eachData.'<br>';
}
PHP字典树(Trie树)定义与实现方法示例
10-19
以下是一个简单的PHP字典树实现： ```php class Node { public $value; public $is_end = false; public $childNode = array(); public function &addChildNode($value, $is_end = false) { // ... } ...
【ShuQiHere】深入解析 B+ 树（B+ Tree）：删除操作与平衡维护的机制
最新发布
ShuQIHere的博客
09-27 1059
掌握 B+ 树的结构和操作逻辑，不仅可以帮助我们应对大规模数据处理挑战，也能提升我们对数据结构设计的理解与优化能力。如果删除操作导致叶子节点中的键值数量少于最低要求（M/2），通常可以从相邻的兄弟节点借用键值以保持树的平衡。，B+ 树显著减少了树的高度，从而减少了每次查找、插入和删除操作时所需的磁盘访问次数。此时，需要对父节点进行调整，可能会触发进一步的借用或合并操作，直到树恢复平衡。合并后，两个节点的键值被合并到一个节点中，并且父节点中的分隔键将被删除。，并更新父节点中的分隔键，从而维持树的平衡。
B树概念和插入实现
weixin_57023347的博客
11-22 4645
介绍B树概念，插入实现。 介绍B+，B*树 介绍B树应用
php-算法-树-B+树的实现
技无涯的博客
05-09 352
php-树-B+树的实现
经典树结构——B+树的原理及实现
热门推荐
c630843901的博客
11-19 3万+
文章目录B+树的概念B+树实现B+树节点参数B+树插入实现B+树删除实现 B+树的概念 规则: B+跟B树不同B+树的非叶子节点不保存关键字记录的指针，只进行数据索引，这样使得B+树每个非叶子节点所能保存的关键字大大增加 B+树叶子节点保存了父节点的所有关键字记录的指针，所有数据地址必须要到叶子节点才能获取到。所以每次数据查询的次数都一样 B+树叶子节点的关键字从小到大有序排列，左边结尾数据都会保存右边节点开始数据的指针 非叶子节点的子节点数=关键字数（来源百度百科）(Mysql 的B+树） B+树相比
B+树的实现
gaoyi的专栏
05-23 1万+
前面讲了B树的实现方法，今天一起看一下B+树，这是什么东东？它是一种类似B树的东西，它融合了多路查找树的快速查找和线性表的顺序查找两种优点，所以特别适合做线性表的索引，比如你现在有一个线性表，其中的数据有1000万条，我们要从中查出连续的10条数据，如果从头到脚的一个一个地查找下去，效率会很低，速度很慢，你的老板也会让你拜拜，那么我们该如何设计一个算法，既能实现快速定位，又能连续取出某段范围的数据...
php+mysql查询优化简单实例
12-19
由于MySQL的B+树索引，这个查询可以非常快速地定位到所需记录。 在30万条记录的表中，第一条语句执行时间约40到50秒，而第二条语句只需0.06秒，性能提升了数百倍。这个例子清楚地展示了优化SQL查询的重要性。避免...
PHP实现克鲁斯卡尔算法实例解析
10-25
最后，Edge类中实现了kruscal算法方法，该方法返回一个最小生成树的结果。 实例中定义了一个名为“edge.php”的文件，其中包含了Edge类和EdgeArc类的定义。在主文件中首先引入了edge.php文件，定义了顶点数组a和边...
PHP实现图的邻接矩阵表示及几种简单遍历算法分析
10-18
在本文中，我们将深入探讨如何使用PHP实现图的邻接矩阵表示，并介绍三种常见的图遍历算法：佛洛依德算法、迪杰斯特拉算法和克鲁斯卡尔算法。 首先，我们来理解什么是邻接矩阵。邻接矩阵是图的一种表示方式，它是一...
全文索引的简单实现PHP版本
04-15
- 使用位图索引或B树等其他数据结构，适应不同场景的需求。 - 考虑内存限制，可能需要将索引存储到磁盘，并使用数据库系统（如SQLite）进行管理。 这个名为"allIndex"的压缩文件可能包含了实际的PHP代码实现，用于...
B+树详解(附代码)
qq_39454212的博客
11-07 4177
我们谈起B+树，可能最先想到它是MySQL中底层存储所采用的数据结构，其实B+树和二叉树、平衡二叉树一样，都是经典的数据结构。B+树由B树和索引顺序访问方法（ISAM，是不是很熟悉？对，这也是MyISAM引擎最初参考的数据结构）演化而来，MongDB中就采用的B树。 为啥MySQL中不采用B树，而采用B+树呢？(或者说MongDB中为啥不采用B+树呢？) 这是因为MySql是关系型数据库，数据的关联性是非常强的，区间访问是常见的一种情况，底层索引组织数据使用B+树，B+树由于数据全部存储在叶子节点，并且通过
关于B+树的介绍、用途和c++代码实现
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
05-12 3576
数据结构和算法的重要性不言而喻，一些优秀的开源项目的核心和灵魂就是数据结构、算法。在实际的编程中我们经常可以在各种框架、算法中看见B树、B+树的身影。特别是在数据库的数据库引擎中，它们更是占据着重要的地位。 下面我将通过简单的二叉树，到树的进化，多叉树(B树、B+树)的由来、作用、操作以及它们在实际中的应用依次进行详细说明。
php b+树,PHP利用b+树概念实现树形数组
weixin_39747296的博客
03-25 151
算法特点：利用b+树概念，只用一次循环就可生成树形数组 //测试数据 $ar = array( array(id=>1,pid=>0), array(id=>2,pid=>0), array(id=>3,pid=>2), array(id=>4,pid=>0), array(id=>5,pid=>3), array(id=...
白话解析B+树并附Java完整实现
qq_36456827的博客
12-28 5590
白话解析B+树并附Java完整实现
B+树详解以及Java代码新增删除实现方式
weixin_43956454的博客
02-18 1920
数据结构模拟网址通俗的说的键是有序的,节点内部的键从左到右依次增大 ,B+树与B树的区别B+树具体信息均存放在叶节点、叶子节点形成一个链表。
B+树详解与实现
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
05-02 1534
B+树是一种树数据结构，通常用于数据库和操作系统的文件系统中。它的特点是能够保持数据稳定有序，其插入与修改拥有较稳定的对数时间复杂度。B+树元素自底向上插入，这与二叉树恰好相反。B+树在节点访问时间远远超过节点内部访问的时候，比可作为替代的实现有着实在的优势。通过最大化在每个内部节点内的子节点的数目减少树的高度，平衡操作不经常发生，而且效率增加了。这种价值得以确立通常需要每个节点在次级存储中占据完整的磁盘块或近似的大小。B+树是B树的一种变形形式，B+树上的叶子结点存储关键字以及相应记录的地址
B树的原理及代码实现、B+树和B*树介绍及应用
weixin_61857742的博客
01-03 2175
B树主要用于磁盘文件的检索操作。众所周知，平衡二叉树（AVL树、红黑树）搜索的时间复杂度是O(log^n)。虽然很快，但如果数据在磁盘中且有上亿量级的数据，即便只有30次左右的IO操作，速度也是非常慢的。因为磁盘IO速度极慢，主要是寻道操作影响，平均8ms左右。因此，磁盘数据的检索不适合使用平衡二叉树，B树正式上线。B树可以看成是压缩版的平衡二叉树，每一个节点上都有保存有多个值，且有多个叶子节点。一般而言，B树的检索次数在个位量级，这取决于每个节点上能保存多少个值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值