B树的插入操作

B树又称B-树

1.一棵M阶的B-树，每个节点最多有M个子树，(M-1)个Key。

2.若某个节点有N个Key，那这个节点就有N+1个子树P。 P0<Key(0)<P1, P0 < P1 < P3

3.当某个节点的Key个数大于等于(M-1)时，该节点需要被分裂；分裂时从中间的那个key为中点，分裂成左右两半；中间的key加入到它的父节点元素中，分裂出来的子树加入到父节点的孩子中;循环往复，直到所有节点都满足1,2两个条件。

#ifndef _BTREE_H_
#define _BTREE_H_

#define MAX_N (4)      // 4叉树

typedef int __INT64;
typedef unsigned int __UINT64;
typedef short __INT32;
typedef unsigned short __UINT32;
typedef char __INT8;
typedef unsigned char __UINT8;

typedef int ElementType;

typedef struct BTNode
{
    BTNode* parent;                   // 父节点
    __INT64 arr[MAX_N + 1];         // 数据
    __INT64 data_cnt;               // 数据个数
    BTNode* child[MAX_N + 2];         // 子树
}BTNode, *BTree;

class CBTree
{
// private variables
private:
    BTree m_pRoot;

// private functions
private:
    void AppendData(BTree &pRoot, ElementType data);
    void AppendTree(BTree &pRoot, BTree &pSubTree);
    __INT64 GetChildCount(const BTree& pRoot);
    // for debug
    void DispNode(const BTree &pRoot);
    BTree NewNode(const BTree &parent);
    void FreeNode(BTree &pRoot);
    __INT64 FindInsertPos(const BTree &pRoot, ElementType data);
    void SplitNode(BTree &pRoot);
    int FindChildTreePos(const BTree &pRoot);
    BTree MergeToParent(BTree &pRoot);
   
public:
    CBTree();
    ~CBTree();
    void InsertNode(ElementType data);
    void WidthFirstSearch();
    void DestroyTree();
};



#endif

#include "btree.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stdarg.h>
#include <time.h>
    
#include "stack.h"
#include "linklist.h"
#include "btree.h"

#define dbg(fmt, param...)                                      \
        do                                                      \
        {                                                       \
            printf("[%s:%d] "fmt, __FILE__, __LINE__, ##param); \
        }while(0)
    
// 计算数组总长度
#define ARRAY_SIZE(arr) sizeof((arr))/sizeof((arr[0]))

// 输出错误,结束进程
void err_print(const char *fmt, ...)
{
    char buff[256] = { 0 };
    va_list vlist;
    va_start(vlist, fmt);
    vsnprintf(buff, sizeof(buff) - 1, fmt, vlist);
    va_end(vlist);
    printf(buff);
    exit(0);
}

CBTree::CBTree()
{
    m_pRoot = NULL;
}

CBTree::~CBTree()
{
    DestroyTree();
}

// 添加数据,插入排序
void CBTree::AppendData(BTree &pRoot, ElementType data)
{
    if(pRoot->data_cnt >= ARRAY_SIZE(pRoot->arr))
    {
        err_print("data count:%d reached maximun count:%d, can't append data now\n", pRoot->data_cnt, ARRAY_SIZE(pRoot->arr));
    }
    if(pRoot->data_cnt == 0)
    {
        pRoot->arr[0] = data;
        pRoot->data_cnt = 1;
        return;
    }

    int i = 0;
    for(;i < pRoot->data_cnt; i++)
    {
        if(data < pRoot->arr[i])
        {
            for(int j = pRoot->data_cnt; j > i; j--)
            {
                pRoot->arr[j] = pRoot->arr[j - 1];
            }
            
            break;
        }
    }
    pRoot->arr[i] = data;
    pRoot->data_cnt++;
}

// 获取子树个数
__INT64 CBTree::GetChildCount(const BTree& pRoot)
{
    int count = 0;
    for(int i=0;i<ARRAY_SIZE(pRoot->child);i++)
    {
        if(pRoot->child[i])
        {
            count++;
        }
    }

    return count;
}

// for debug
void CBTree::DispNode(const BTree &pRoot)
{
    printf("head(%d):", pRoot->data_cnt);
    for(int i=0;i<pRoot->data_cnt;i++)
    {
        printf("%d ", pRoot->arr[i]);
    }
    printf("\n");
    for(int i=0;i<GetChildCount(pRoot);i++)
    {
        if(pRoot->child[i] != NULL)
        {
            printf(" child[%d]:", i);
            for(int j=0;j<pRoot->child[i]->data_cnt;j++)
            {
                printf("%d ", pRoot->child[i]->arr[j]);
            }
            printf("\n");
        }
    }
    printf("\n");
}

// 填加树,插入排序
void CBTree::AppendTree(BTree &pRoot, BTree &pSubTree)
{
    if(pRoot == NULL || pSubTree == NULL)
    {
        return;
    }
    if(pRoot->data_cnt == 0)
    {
        err_print("error! tree data count is 0\n");
    }
    
    int nChildCnt = GetChildCount(pRoot);
    if(nChildCnt == 0)
    {
        pRoot->child[0] = pSubTree;
        pSubTree->parent = pRoot;
        return;
    }

    int iSubTreeMax = 0;
    if(pSubTree->data_cnt > 0)
    {
        iSubTreeMax = pSubTree->arr[pSubTree->data_cnt - 1];
    }

    int i = 0;
    for(i = 0; i < nChildCnt; i++)
    {
        if(pRoot->child[i] != NULL)
        {
            BTree pItreeChild = pRoot->child[i];
            if(pItreeChild->data_cnt == 0)
            {
                err_print("error! tree data count shouldn't be 0\n");
            }


            int iMax = pItreeChild->arr[pItreeChild->data_cnt - 1];
            // 2=>升序1   _ 3 5
            if(iSubTreeMax < iMax)
            {
                for(int j = nChildCnt; j > i; j--)
                {
                    pRoot->child[j] = pRoot->child[j - 1];
                }

                break;
            }
        }
    }
    pRoot->child[i] = pSubTree;
    pSubTree->parent = pRoot;
}

// 申请新空节点
BTree CBTree::NewNode(const BTree &parent)
{
    BTree pNode = new BTNode;
    if(pNode == NULL)
    {
        return NULL;
    }

    for(int i=0;i<ARRAY_SIZE(pNode->arr);i++)
    {
        pNode->arr[i] = 0;
    }

    for(int i=0;i<ARRAY_SIZE(pNode->child);i++)
    {
        pNode->child[i] = NULL;
    }

    pNode->data_cnt = 0;
    pNode->parent = parent;

    return pNode;
}

// 释放当前节点
void CBTree::FreeNode(BTree &pRoot)
{
    if(pRoot)
    {
        for(int i=0;i<ARRAY_SIZE(pRoot->child); i++)
        {
            pRoot->child[i] = NULL;
        }
        pRoot->data_cnt = 0;
        pRoot->parent = NULL;
    
        delete pRoot;
        pRoot = NULL;
    }
}

// 查找插入位置
__INT64 CBTree::FindInsertPos(const BTree &pRoot, ElementType data)
{
    __INT64 idx = 0;
    for(idx = 0; idx < pRoot->data_cnt && idx < (MAX_N + 1); idx++)
    {
        if(data < pRoot->arr[idx])
        {
            return idx;
        }
    }
    return idx;
}

// 分裂树
void CBTree::SplitNode(BTree &pRoot)
{
    if(pRoot->data_cnt <= MAX_N)
    {
        printf("data_cnt not reach maximun, don't need to split node.\n");
        return;
    }

    __INT64 nMidDatIdx  = pRoot->data_cnt / 2;

    // 当前节点下生成2个新树
    BTree lpLeft  = NewNode(pRoot);   
    BTree lpRight = NewNode(pRoot);

    assert(lpLeft != NULL);
    assert(lpRight != NULL);


    // 重新分配数据
    for(__INT64 i = 0; i < nMidDatIdx; i++)
    {
        AppendData(lpLeft, pRoot->arr[i]);
    }

    for(__INT64 i = nMidDatIdx + 1; i < pRoot->data_cnt; i++)
    {
        AppendData(lpRight, pRoot->arr[i]);
    }

    pRoot->arr[0] = pRoot->arr[nMidDatIdx];
    pRoot->data_cnt = 1;

    // 重新分配子树
    __INT64 nChildCnt    = GetChildCount(pRoot);
    __INT64 nMidChildIdx = (lpLeft->data_cnt > lpRight->data_cnt) ? ((nChildCnt+1)/2) : nChildCnt/2;

    for(__INT64 i = 0;i < nMidChildIdx; i++)
    {
        AppendTree(lpLeft, pRoot->child[i]);
    }

    for(__INT64 i=nMidChildIdx; i<nChildCnt; i++)
    {
        AppendTree(lpRight, pRoot->child[i]);
    }

    // 清空子树
    for(__INT64 i = 0; i < ARRAY_SIZE(pRoot->child); i++)
    {
        pRoot->child[i] = NULL;
    }


    // 当前节点增加新生成的2棵子树
    AppendTree(pRoot, lpLeft);
    AppendTree(pRoot, lpRight);
}

// 查找当前节点是父节点的第几个树节点
int CBTree::FindChildTreePos(const BTree &pRoot)
{
    BTree hParent = pRoot->parent;
    for(__INT64 i = 0;i < ARRAY_SIZE(pRoot->child); i++)
    {
        if(hParent->child[i] != NULL &&
           hParent->child[i] == pRoot)
        {
            return i;
        }
    }
    return -1;
}

// 向上合入父节点
BTree CBTree::MergeToParent(BTree &pRoot)
{
    if(pRoot == NULL || pRoot->parent == NULL) // 没有父节点的时候,不用合入
    {
        return pRoot;
    }

    BTree hParent = pRoot->parent;             // 当前节点的父节点

    __INT64 child_pos = FindChildTreePos(pRoot);
    if(child_pos == -1)
    {
        err_print("can't find child pos, root data:%d.\n", pRoot->arr[0]);
    }
    
    // 置空子树在父节点中的位置
    int nParentChildCnt = GetChildCount(hParent);
    if(nParentChildCnt == 1)
    {
        hParent->child[0] = NULL;
    }
    else
    {
        for(int i = child_pos;i < nParentChildCnt - 1; i++)
        {
            hParent->child[i] = hParent->child[i + 1];
        }
        hParent->child[nParentChildCnt - 1] = NULL;
    }

    // 追加所有数据
    for(int i=0;i<pRoot->data_cnt;i++)
    {
        AppendData(hParent, pRoot->arr[i]);
        pRoot->arr[i] = 0;
    }
    pRoot->data_cnt = 0;

    // 追加所有子节点
    for(__INT64 i = 0; i < ARRAY_SIZE(pRoot->child); i++)
    {
        if(pRoot->child[i] != NULL)
        {
            AppendTree(hParent, pRoot->child[i]);
            pRoot->child[i] = NULL;
        }
    }
    
    // 释放节点
    FreeNode(pRoot);

    return hParent;
}

// 广度优先遍历
void CBTree::WidthFirstSearch()
{
    if(m_pRoot == NULL)
    {
        return;
    }

    char szPrtBuf[1024] = { 0 };

    CLinkList<BTree> treelist1;
    CLinkList<BTree> treelist2;

    treelist1.Pushback(m_pRoot);

    printf("======================================\n");
    printf("tree struct:\n");
    do
    {
        while(!treelist1.IsEmpty())
        {
            BTree pTreeNode = NULL;
            treelist1.GetHead(pTreeNode);
            treelist1.RemoveHead();
            if(pTreeNode == NULL)
            {
                continue;
            }
            char tmp[256] = "head:";
            strcat(szPrtBuf, tmp);
            for(int i=0;i<pTreeNode->data_cnt;i++)
            {
                snprintf(tmp, sizeof(tmp) - 1, "%d ", pTreeNode->arr[i]);
                strcat(szPrtBuf, tmp);
            }
            strcat(szPrtBuf, "\n");
            for(int i=0;i<ARRAY_SIZE(pTreeNode->child);i++)
            {
                if(pTreeNode->child[i])
                {
                    snprintf(tmp, sizeof(tmp) - 1, " child[%d]:", i);
                    strcat(szPrtBuf,tmp);
                    for(int j=0;j<pTreeNode->child[i]->data_cnt;j++)
                    {
                        snprintf(tmp, sizeof(tmp) - 1, "%d ",pTreeNode->child[i]->arr[j]);
                        strcat(szPrtBuf, tmp);
                    }
                    strcat(szPrtBuf, "\n");
                }
            }

            for(int i = 0; i < pTreeNode->data_cnt; i++)
            {
                printf("%d ", pTreeNode->arr[i]);
            }
            printf(",");

            for(int i = 0;i < ARRAY_SIZE(pTreeNode->child); i++)
            {
                if(pTreeNode->child[i] != NULL)
                {
                    treelist2.Pushback(pTreeNode->child[i]);
                }
            }
        }
        printf("\n");

        while(!treelist2.IsEmpty())
        {
            BTree pTreeNode = NULL;
            treelist2.GetHead(pTreeNode);
            treelist2.RemoveHead();
            if(pTreeNode == NULL)
            {
                continue;
            }

            char tmp[256] = "head:";
            strcat(szPrtBuf, tmp);
            for(int i=0;i<pTreeNode->data_cnt;i++)
            {
                snprintf(tmp, sizeof(tmp) - 1, "%d ", pTreeNode->arr[i]);
                strcat(szPrtBuf, tmp);
            }
            strcat(szPrtBuf, "\n");
            for(int i=0;i<ARRAY_SIZE(pTreeNode->child);i++)
            {
                if(pTreeNode->child[i])
                {
                    snprintf(tmp, sizeof(tmp) - 1, " child[%d]:", i);
                    strcat(szPrtBuf,tmp);
                    for(int j=0;j<pTreeNode->child[i]->data_cnt;j++)
                    {
                        snprintf(tmp, sizeof(tmp) - 1, "%d ",pTreeNode->child[i]->arr[j]);
                        strcat(szPrtBuf, tmp);
                    }
                    strcat(szPrtBuf, "\n");
                }
            }


            for(int i=0;i<pTreeNode->data_cnt;i++)
            {
                printf("%d ", pTreeNode->arr[i]);
            }
            printf(",");
            for(int i = 0;i < ARRAY_SIZE(pTreeNode->child); i++)
            {
                if(pTreeNode->child[i] != NULL)
                {
                    treelist1.Pushback(pTreeNode->child[i]);
                }
            }
        }
        printf("\n");
    }while(!treelist1.IsEmpty() || !treelist2.IsEmpty());

    printf("tree nodes:\n%s", szPrtBuf);
    printf("======================================\n");
}

// 插入节点
void CBTree::InsertNode(ElementType data)
{
    if(m_pRoot == NULL)
    {
        m_pRoot = NewNode(NULL);
        AppendData(m_pRoot, data);
        return;
    }
    printf("Insert Data:%d\n", data);

    assert(m_pRoot != NULL);

    BTree pHead = m_pRoot;
    while(pHead)
    {
        if(pHead->data_cnt == 0)
        {
            AppendData(pHead, data);
            break;
        }
        else
        {
            __INT64 ins_pos = FindInsertPos(pHead, data);
            if(ins_pos > MAX_N)
            {
                err_print("findinsert pos err, ins_pos out of max range\n");
            }
            //DispNode(pHead);
            //printf("ins pos = %d\n", ins_pos);
            // 对应的子树存在则到跳到子树,否则直接插入
            if(pHead->child[ins_pos])
            {
                pHead = pHead->child[ins_pos];
            }
            else
            {
                AppendData(pHead, data);
                while(pHead && pHead->data_cnt > MAX_N)
                {
                    SplitNode(pHead);                  // 分裂当前节点
                    pHead = MergeToParent(pHead);      // 当前节点合入父节点
                }
                break;
            }
       }
    }
    WidthFirstSearch();
}

void CBTree::DestroyTree()
{
    if(m_pRoot == NULL)
    {
        return;
    }

    printf("destroying tree\n");

    CStack<BTree> nodeStack;
    nodeStack.Push(m_pRoot);

    while(!nodeStack.isEmpty())
    {
        BTree top = NULL;
        nodeStack.Pop(top);
        if(top)
        {
            for(int i=0;i<ARRAY_SIZE(top->child);i++)
            {
                if(top->child[i] != NULL)
                {
                    nodeStack.Push(top->child[i]);
                }
            }
            DispNode(top);
            FreeNode(top);
        }
    }
    m_pRoot = NULL;
}