数据结构——B-树的查找和插入

#include <iostream>
#include <math.h>
using namespace std;

#define M 4        //B-树的阶，暂设为4
#define false 0
#define true 1

typedef struct BTNode
{
    int                keynum;            //节点中关键字个数，即节点的大小
    struct BTNode    *parent;        //指向双亲结点
    int                key[M+1];        //关键字向量，0号单元未用
    struct BTNode    *son[M+1];        //子树指针向量
    //Record        *recptr[M+1];    //记录指针向量，0号单元未用(文件中使用)
}BTNode, *BTree;        //B-树节点和B-树的类型

typedef struct
{
    BTNode            *pt;            //指向找到的节点
    int                pos;                //1...m,在节点中的关键字序号
    int                tag;            //1:查找成功，0:查找失败
}Result;        //B-树的查找结果类型



//初始化
void init_BTree(BTree &root)
{
    root=NULL;
}


int search(BTree &p,int key)
{
    int j;
    for(j=1; j<=p->keynum; j++)
        if(p->key[j] > key)
        {
            break;
        }
    return j-1;        //应该插入的位置的前一位
}
Result searchBtree(BTree &root, int key)
{
    //在m阶B树t上查找关键码key，反回(pt,i,tag)。
    //若查找成功，则特征值tag=1，指针pt所指结点中第i个关键码等于key；
    //否则，特征值tag=0,等于key的关键码记录,应插入在指针pt所指结点中第i个和第i+1个关键码之间
    int found=false;
    int i;
    BTree p=root,father=NULL;    //初始化，p指向待查节点，q指向p的双亲
    Result    result;        //SearchBTree函数返回值

    while(p && !found)
    {
        i=search(p,key);    //p->node[i].key≤K<p->node[i+1].key
        if(i>0 && p->key[i]==key)
        {
            found=true;        //找到待查关键字
        }
        else 
        {
            father=p;
            p=p->son[i];
        }
    }
    result.pos=i+1;        //pos是插入的位置,记住加1
    if(found)    //查找成功
    {
        result.pt=p;
        result.tag=1;    
    }
    else    //查找不成功，返回key的插入位置i
    {
        result.pt=father;
        result.tag=0;    
    }
    return result;
}//SearchBTree

//细胞分裂
void split(BTree &q, int s, BTree &ap)
{
    // 将结点q分裂成两个结点，前一半保留，后一半移入新生结点ap
    int i;
    cout<<"分裂!"<<"  "<<q->key[s]<<endl;
    ap=(BTree)malloc(sizeof(BTNode));        //生成新结点ap
    ap->son[0] = q->son[s];            //原来结点中间位置关键字相应指针指向的子树放到新生成结点的0棵子树中去
    for(i=s+1;i<=M;i++)        //后一半移入ap
    {
        ap->key[i-s]=q->key[i];
        ap->son[i-s]=q->son[i];
    }//for
    ap->keynum=M-s;
    ap->parent=q->parent;
    q->keynum=s-1;        //q的前一半保留，修改keynum
}//split

void NewRoot(BTree &root, int x, BTree &ap)        //生成新的根节点
{
    //生成含信息(root,r,ap)的新的根结点*root，原root和ap为子树指针
    BTree p;
    p=(BTree)malloc(sizeof(BTNode));
    if(root)    //如果原来的树不是空树
        root->parent=p;                    //远来的根的双亲指针指向新根
    p->son[0]=root;                        //新根的第一个孩子节点是原来的根节点
    root=p;        //root指向新根    
    root->parent=NULL;                    //新根的双亲是空指针
    root->keynum=1;            
    root->key[1]=x;                        //新根的第一个关键字就是前面分裂出来的关键字
    root->son[1]=ap;                    //新根的第二个孩子节点是原来的根中分裂出来的节点
    if(ap)        //如果原来的树不是空树
        ap->parent=root;                //原来的根中分裂出来的节点的双亲指针指向新根
}//NewRoot

void insert(BTree &q, int i, int key, BTree &ap)    //插入
{
    int j;
    for(j=q->keynum; j>=i; j--)
    {
        q->key[j+1]=q->key[j];
    }
    q->key[i]=key;
    for(j=q->keynum; j>=i; j--)
    {
        q->son[j+1]=q->son[j];
    }
    q->son[i]=ap;
    q->keynum++;
}//insert
void insertBtree(BTree &root, int key, BTree &q, int i)
{
    //在B-树T上节点q的key[i]和key[i+1]之间插入关键字key
    //若引起节点过大，则沿双亲链进行必要的节点分裂整理，使T仍是M阶的B-树
    BTree ap=NULL;
    int x=key;
    int finished = false;
    int s;
    while(q && !finished)
    {
        insert(q, i, x, ap);    //将key和ap分别插入到q->key[i+1]和q->son[i+1]
        if(q->keynum <    M)
            finished = true;    //插入完成
        else
        {    //分裂结点*q
            s=ceil(M/2);
            x=q->key[s];
            split(q, s, ap);    //将q->key[s+1...M],q->son[s...M]和q->recptr[s+1...M]移入到新节点*ap
            q=q->parent;
            if(q)
                i=search(q,x)+1;        //在双亲结点*q中去查找x的插入位置,记住加1，因为search()返回的是插入位置的前一位
        }//else
    }//while
    if(!finished)                //root是空树(参数q初值为NULL)或者根节点已分裂为节点*q和*ap
        NewRoot(root, x, ap);    //生成含信息(root,x,ap)的新的根节点*root，原root和ap为子树指针
 }//insertBtree

void SearchInsertBTree(BTree &root,int key)//搜索插入
{ 
    //在m阶B树*t上结点*q的key[i],key[i+1]之间插入关键码key
    //若引起结点过大，则沿双亲链进行必要的结点分裂调整，使*t仍为m阶B树
    Result    rs;
    rs = searchBtree(root,key);
    if(!rs.tag)    //tag=0查找不成功，插入
    {
        cout<<"树中没有相同的节点，插入!"<<endl;
        insertBtree(root, key, rs.pt, rs.pos);    //在B-树T上节点re.pt的key[i]和key[i+1]之间插入关键字key
    }
    else
    {
        cout<<"树中已有相同的节点!"<<endl;
    }
}//InserBTree 





int main()
{
    BTree Root;
    init_BTree(Root);            //初始化

    //插入测试
    int key;
    /*cout<<"输入要插入的节点，以0结束输入:"<<endl;
    cin>>key;
    while(key)
     {
        SearchInsertBTree(Root,key);
        cin>>key;
    }*/
    SearchInsertBTree(Root,45);
    SearchInsertBTree(Root,24);
    SearchInsertBTree(Root,53);
    SearchInsertBTree(Root,90);
    SearchInsertBTree(Root,3);
    SearchInsertBTree(Root,37);
    SearchInsertBTree(Root,50);
    SearchInsertBTree(Root,61);
    SearchInsertBTree(Root,70);
    SearchInsertBTree(Root,100);


    //打印测试
    cout<<endl<<"按关键字的顺序遍历B_树:"<<endl;
    TraverseBTree(Root);
    
    //查找测试
    //cout<<endl<<"输入要查找的节点，以0结束输入:"<<endl;
    //cin>>key;
    //while(key)
    //{
    //    UserSearch(Root,key);
    //    cin>>key;
    //}
    
    //销毁测试
    DestroyBTree(Root);
    return 0;
}/*End of main()*///销毁B-树
void DestroyBTree(BTree &root)
{
    int i;
    if(root) //非空树
    {
         for(i=0; i<=root->keynum; i++)
             if(root->son[i])
                DestroyBTree(root->son[i]);
         free(root);
         root=NULL;
         cout<<"销毁成功"<<endl;
    }//if
}//搜索关键字
void UserSearch(BTree &root,int key)
{
    Result s;
    s=searchBtree(root,key);
    if(s.tag)
        cout<<"找到关键字!"<<endl;
    else
        cout<<"没找到!"<<endl;
}//UserSearch
void print(BTree &p,int i) // TraverseBTree()调用的函数
{
    cout<<p->key[i]<<"  ";
}//print
void TraverseBTree(BTree &root)    //按关键字的顺序遍历B_树
{
    int i;
    if(root)    //非空树
    {
        if(root->son[0])    //有第0棵子树
        {
            cout<<endl<<"第0棵子树"<<endl;
            TraverseBTree(root->son[0]);
        }
        for(i=1; i<=root->keynum; i++)
        {
            print(root,i);
            if(root->son[i])    //有第i棵子树
            {
                cout<<endl<<"第"<<i<<"棵子树"<<endl;
                TraverseBTree(root->son[i]);
            }
        }//for
    }//if
}//TraverseBTree