B+树的一个实现

B+树是现在很多数据库索引技术的基础，也是讨论比较多的一种数据结构。而很多书上对它只有描述性的定义，并无伪代码的描述。因此，在真正实现B+树的时候，难免会掉入一些思维的陷进。因为本文主要来讲讲笔者在实现一个简单的B+树时注意的问题。最后将会给出一个实现好的B+树。（未完）

 

首先还是谈谈什么时候B+树？

 

B+ 树是一种树数据结构，通常用于数据库和操作系统的文件系统中。B+ 树的特点是能够保持数据稳定有序，其插入与修改拥有较稳定的对数时间复杂度。B+ 树元素自底向上插入，这与二叉树恰好相反。

B+ 树在节点访问时间远远超过节点内部访问时间的时候，比可作为替代的实现有着实在的优势。这通常在多数节点在次级存储比如硬盘中的时候出现。通过最大化在每个内部节点内的子节点的数目减少树的高度，平衡操作不经常发生，而且效率增加了。这种价值得以确立通常需要每个节点在次级存储中占据完整的磁盘块或近似的大小。

B+ 背后的想法是内部节点可以有在预定范围内的可变数目的子节点。因此，B+ 树不需要象其他自平衡二叉查找树那样经常的重新平衡。对于特定的实现在子节点数目上的低和高边界是固定的。例如，在 2-3 B 树（常简称为2-3 树）中，每个内部节点只可能有 2 或 3 个子节点。如果节点有无效数目的子节点则被当作处于违规状态。

B+ 树的创造者 Rudolf Bayer 没有解释B代表什么。最常见的观点是B代表平衡(balanced)，因为所有的叶子节点在树中都在相同的级别上。B也可能代表Bayer，或者是波音（Boeing），因为他曾经工作于波音科学研究实验室。

 

#include <stdlib.h>
#include <memory>
#include <queue>

using namespace std;

#define N 200
#define NUM (2*N)

struct BTreeNode;

typedef struct BTreeInnerNode
{
    BTreeNode * child[NUM+1];
} BTreeInnerNode;

typedef struct BTreeLeafNode
{
    int value[NUM];
    int isDelete[NUM];
    BTreeNode * next;
} BTreeLeafNode;

typedef union Node
{
    BTreeInnerNode innerNode;
    BTreeLeafNode leafNode;
} Node;

typedef struct BTreeNode
{
    int number;
    int isLeaf;
    int key[NUM];
    int level;
    Node valueNode;
} BTreeNode;

BTreeNode * root = NULL;

void Insert(int key, int value);
int Delete(int key);
int Query(int key);

BTreeNode * InnerTravel(BTreeNode * node, int key);
BTreeNode * CreateNode();
void SplitNodeNPutLeafItem(BTreeNode * node, int key, int value);
void SplitNodeNPutInnerItem(BTreeNode * fnode, BTreeNode * node);

void PutLeafItem(BTreeNode * node, int key, int value);
int GetLeafItem(BTreeNode * node, int key);
int DelLeafItem(BTreeNode * node, int key);


void PutInnerItem(BTreeNode * node, BTreeNode * cnode, int key);
int GetInnerItem(BTreeNode * node, int key);
void DelInnerItem(BTreeNode * node, int key);

int GetMin(BTreeNode * node);
BTreeNode * GetParent(BTreeNode * node);

void Print();
void PrintTree();
bool ValidateTree();

int _tmain(int argc, _TCHAR* argv[])
{
    //Insert(2, 2);
    //Insert(3, 3);
    //Insert(5, 5);
    //Insert(7, 7);

    //Insert(11, 11);
    //Insert(13, 13);
    //Insert(17, 17);
    //Insert(19, 19);

    //Insert(41, 41);
    //Insert(43, 43);
    //Insert(47, 47);

    ////Insert(40, 40);

    //Insert(23, 23);
    //Insert(29, 29);
    //Insert(31, 31);
    //Insert(37, 37);

    //PrintTree();

    //Insert(40, 40);

    //PrintTree();

    int isError;

    //////////////////////////////////

    isError = 0;

    for(int i=20000; i>10000; i--)
    {
        Insert(i, i+1);
        //if(!ValidateTree())
        //{
        //    printf("Error in %d\n", i);
        //    isError = 1;
        //    break;
        //}
    }

    //if(isError == 0)
    //{
    //    PrintTree();
    //}

    /////////////////////////////////

    isError = 0;

    for(int i=0; i<10000; i++)
    {
        Insert(i, i+1);
        //if(!ValidateTree())
        //{
        //    printf("Error in %d\n", i);
        //    break;
        //}
    }

    //if(isError == 0)
    //{
    //    PrintTree();
    //}

    printf("%d\n", Query(100));

    printf("%d\n", Delete(100));

    printf("%d\n", Query(100));

    return 0;
}

void Insert(int key, int value)
{
    BTreeNode * node = NULL;
    BTreeNode * nnode = NULL;
    BTreeNode * rnode = NULL;
    
    if(root != NULL)
    {
        node = InnerTravel(root, key);
    }
    else
    {
        node = root = CreateNode();
        node->isLeaf = 1;
    }

    if(node->number < NUM)
    {
        PutLeafItem(node, key, value);
    }
    else
    {
        SplitNodeNPutLeafItem(node, key, value);
    }
}

int Delete(int key)
{
    BTreeNode * node = NULL;
    if(root != NULL)
    {
        node = InnerTravel(root, key);
    }
    else
    {
        return -1;
    }

    return DelLeafItem(node, key);
}

int Query(int key)
{
    BTreeNode * node = NULL;
    if(root != NULL)
    {
        node = InnerTravel(root, key);
    }
    else
    {
        return -1;
    }

    return GetLeafItem(node, key);
}


BTreeNode * CreateNode()
{
    BTreeNode * node = (BTreeNode *)malloc(sizeof(BTreeNode));
    memset(node, 0, sizeof(BTreeNode));

    return node;
}

BTreeNode * InnerTravel(BTreeNode * node, int key)
{
    if(node->isLeaf == 1)
    {
        return node;
    }

    for(int i=0; i<node->number; i++)
    {
        if(key < node->key[i])
        {
            return InnerTravel(node->valueNode.innerNode.child[i], key);
        }
    }
    return InnerTravel(node->valueNode.innerNode.child[node->number], key);
}

void SplitNodeNPutLeafItem(BTreeNode * node, int key, int value)
{
    BTreeNode * fnode = NULL;

    BTreeNode * nnode = CreateNode();
    nnode->isLeaf = node->isLeaf;
    nnode->level = node->level;

    for(int i=0; i<N; i++)
    {
        nnode->key[i] = node->key[N+i];
        nnode->valueNode.leafNode.value[i] = node->valueNode.leafNode.value[N+i];
    }

    nnode->number = N;
    node->number = N;

    nnode->valueNode.leafNode.next = node->valueNode.leafNode.next;
    node->valueNode.leafNode.next = nnode;

    if(key < nnode->key[0])
    {
        PutLeafItem(node, key, value);
    }
    else
    {
        PutLeafItem(nnode, key, value);
    }

    fnode = GetParent(node);

    if(fnode == NULL)
    {
        fnode = CreateNode();
        fnode->valueNode.innerNode.child[0] = root;
        fnode->level = root->level + 1;
        root = fnode;
        
    }

    if(fnode->number < NUM)
    {
        PutInnerItem(fnode, nnode, nnode->key[0]);
    }
    else
    {
        SplitNodeNPutInnerItem(fnode, nnode);
    }
    
}

void PutLeafItem(BTreeNode * node, int key, int value)
{
    int insertIndex = node->number;
    for(int i=0; i<node->number; i++)
    {
        if(key < node->key[i])
        {
            insertIndex = i;
            break;
        }
    }

    for(int i=node->number-1; i>=insertIndex; i--)
    {
        node->key[i+1] = node->key[i];
        node->valueNode.leafNode.value[i+1] = node->valueNode.leafNode.value[i];
    }

    node->key[insertIndex] = key;
    node->valueNode.leafNode.value[insertIndex] = value;
    node->number++;
}

int DelLeafItem(BTreeNode * node, int key)
{
    int deleteIndex = -1;
    for(int i=0; i<node->number; i++)
    {
        if(key == node->key[i])
        {
            deleteIndex = i;
            break;
        }
    }
    if(deleteIndex != -1)
    {
        node->valueNode.leafNode.isDelete[deleteIndex] = 1;
    }
    return deleteIndex;
}

int GetLeafItem(BTreeNode * node, int key)
{
    for(int i=0; i<node->number; i++)
    {
        if(key == node->key[i] && node->valueNode.leafNode.isDelete[i] == 0)
        {
            return node->valueNode.leafNode.value[i];
        }
    }
    return -1;
}

void PutInnerItem(BTreeNode * node, BTreeNode * cnode, int key)
{
    int insertIndex = node->number;
    for(int i=0; i<node->number; i++)
    {
        if(key < node->key[i])
        {
            insertIndex = i;
            break;
        }
    }

    for(int i=node->number-1; i>=insertIndex; i--)
    {
        node->key[i+1] = node->key[i];
        node->valueNode.innerNode.child[i+2] = node->valueNode.innerNode.child[i+1];
    }

    node->valueNode.innerNode.child[insertIndex+1] = cnode;
    node->key[insertIndex] = key;

    node->number++;
}


void SplitNodeNPutInnerItem(BTreeNode * fnode, BTreeNode * node)
{
    BTreeNode * nfnode = CreateNode();
    BTreeNode * ffnode = NULL;
    nfnode->isLeaf = fnode->isLeaf;
    nfnode->level = fnode->level;

    int splitValue = fnode->valueNode.innerNode.child[N]->key[0];
    int splitValueAfter = fnode->valueNode.innerNode.child[N+1]->key[0];

    for(int i=0; i<N; i++)
    {
        nfnode->key[i] = fnode->key[N+i];
    }

    nfnode->number = N;
    fnode->number = N;

    if(node->key[0] < splitValue)
    {
        for(int i=0; i<=N; i++)
        {
            nfnode->valueNode.innerNode.child[i] = fnode->valueNode.innerNode.child[N+i];
        }
        
        fnode->number--;
        
        PutInnerItem(fnode, node, GetMin(node));
    }
    else
    {
        if(node->key[0] < splitValueAfter)
        {
            for(int i=0; i<N; i++)
            {
                nfnode->valueNode.innerNode.child[i+1] = fnode->valueNode.innerNode.child[N+i+1];
            }
            nfnode->valueNode.innerNode.child[0] = node;
            nfnode->key[0] = GetMin(nfnode->valueNode.innerNode.child[1]);
        }
        else
        {
            for(int i=0; i<N; i++)
            {
                nfnode->valueNode.innerNode.child[i] = fnode->valueNode.innerNode.child[N+i+1];
            }

            for(int i=0; i<N-1; i++)
            {
                nfnode->key[i] = nfnode->key[i+1];
            }

            nfnode->number--;

            PutInnerItem(nfnode, node, GetMin(node));
        }
    }

    ffnode = GetParent(fnode);

    if(ffnode == NULL)
    {
        ffnode = CreateNode();
        ffnode->valueNode.innerNode.child[0] = root;
        ffnode->level = root->level + 1;
        root = ffnode;
    }

    if(ffnode->number < NUM)
    {
        PutInnerItem(ffnode, nfnode, GetMin(nfnode));
    }
    else
    {
        SplitNodeNPutInnerItem(ffnode, nfnode);
    }
}

BTreeNode * GetParent(BTreeNode * node)
{
    BTreeNode * fnode = root;
    int minKey = node->key[0];

    int num = 0;

    if(node == root)
        return NULL;

    if(root->isLeaf == 1)
        return NULL;

    int isHit = 0;
    
    while(fnode->isLeaf == 0)
    {
        num = fnode->number;
        isHit = 0;

        for(int i=0; i<num; i++)
        {
            if(minKey < fnode->key[i])
            {
                if(fnode->valueNode.innerNode.child[i] == node)
                    return fnode;
                else
                {
                    fnode = fnode->valueNode.innerNode.child[i];
                    isHit = 1;
                    break;
                }
            }
        }

        if(isHit == 0)
        {
            if(fnode->valueNode.innerNode.child[fnode->number] == node)
                return fnode;
            else
            {
                fnode = fnode->valueNode.innerNode.child[fnode->number];
            }
        }
    }
    return NULL;
}

void Print()
{
    BTreeNode * node = root;
    while(node->isLeaf == 0)
    {
        node = node->valueNode.innerNode.child[0];
    }

    do
    {
        for(int i=0; i<node->number; i++)
        {
            printf("%d ", node->valueNode.leafNode.value[i]);
        }
        printf("|");
        node = node->valueNode.leafNode.next;
    }while(node != NULL);

    printf("\n");
}

void PrintTree()
{
    queue<BTreeNode*> nodeQueue;
    BTreeNode * node = root;
    int level = node->level;

    nodeQueue.push(node);

    printf("| ");
    while(!nodeQueue.empty())
    {
        node = nodeQueue.front();

        nodeQueue.pop();

        if(node->isLeaf == 0)
        {
            for(int i=0; i<=node->number; i++)
            {
                nodeQueue.push(node->valueNode.innerNode.child[i]);
            }
        }

        if(level != node->level)
        {
            level--;
            printf("\n| ");
        }

        for(int i=0; i<node->number; i++)
        {
            printf("%d ", node->key[i]);
        }
        printf("| ");

    }
    printf("\n===================================\n");

}

bool ValidateTree()
{
    queue<BTreeNode*> nodeQueue;
    BTreeNode * node = root;
    int level = node->level;

    int value = node->key[0];

    nodeQueue.push(node);

    while(!nodeQueue.empty())
    {
        node = nodeQueue.front();
        nodeQueue.pop();

        if(node->isLeaf == 0)
        {
            for(int i=0; i<=node->number; i++)
            {
                nodeQueue.push(node->valueNode.innerNode.child[i]);
            }
        }

        if(level != node->level)
        {
            value = node->key[0];
            level--;
        }

        for(int i=0; i<node->number; i++)
        {
            if(node->key[i] >= value)
            {
                value = node->key[i];
            }
            else
            {
                printf("node->key[%d]:%d, value:%d\n", i, node->key[i], value);
                return false;
            }

            if(node->isLeaf == 0)
            {
                if(node->key[i] <= node->valueNode.innerNode.child[i]->key[0] || node->key[i] > node->valueNode.innerNode.child[i+1]->key[0])
                {
                    printf("node->key[%d]:%d, child[%d]:%d, child[%d]:%d\n", i, node->key[i], i, node->valueNode.innerNode.child[i]->key[0], i+1, node->valueNode.innerNode.child[i+1]->key[0]);
                    return false;
                }
            }
        }
    }
    return true;
}

int GetMin(BTreeNode * node)
{
    while(node->isLeaf == 0)
    {
        node = node->valueNode.innerNode.child[0];
    }
    return node->valueNode.leafNode.value[0];
}