B-tree的构造及相关操作

#include "bttool.h"


int main()
{
   ElemType data;
   treeNode* root;
   treeNode* treenode;
   root = new treeNode;
   treenode = new treeNode;

   cin>>data;
   treenode = creatbtree(root,data);
   root = treenode;
   while(1)
   {
       cin>>data;
       if(data==0)
       {
           break;
       }
       treenode = creatbtree(root,data);
   }

/*
  cout<<"print  preorderbtree:\n";
  preorderbtree(root);
  cout<<endl;
*/

/*
  cout<<"print inorderbtree:\n";
  inorderbtree(root);
  cout<<endl;
*/

//
//cout<<"print postorderbtree:\n";
//postorderbtree(root);
//cout<<endl;
//


/*
//add  tree node
//preorderbtree(root);
cout<<"\nadd one node:\n";
ElemType adddata;
cin>>newdata;
//treenode = creatbtree(root,adddata);
//treeNode* newtreeroot;
addtreenode(root,newdata);
cout<<"\nthe new b tree:\n";
//preorderbtree(newtreeroot);
inorderbtree(root);
cout<<endl;
*/

/*
//find data
cout<<"input the number:\n";
ElemType finddata;
treeNode* findpnode;
findpnode = new treeNode;
cin>>finddata;
findpnode=findnode(root,finddata);
if(findpnode!=NULL)
{
    cout<<findpnode->data<<" is  find.\n";
}
else
{
    cout<<finddata<<"is not exist.\n";
}
delete findpnode;
*/



//count the nunber of leaves node
int  leavesnum;
leavesnum = findleavesnode(root);
cout<<"the number of leaves  is: "<<leavesnum;
cout<<endl;



/*
//calculate deepth
int dptree;
dptree = calculatedeep(root);
cout<<"the deepth of the tree is: "<<dptree;
cout<<endl;
*/

  return 0;
}

#ifndef _CREAT_B_TREE_
#define _CREAT_B_TREE_

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<algorithm>

using namespace std;

typedef int ElemType;

struct treeNode
{
    ElemType data;
    treeNode *tleft;
    treeNode *tright;
};

treeNode* creatbtree(treeNode* root,ElemType data);
void preorderbtree(treeNode* root);
void inorderbtree(treeNode* root);
void postorderbtree(treeNode* root);
void addtreenode(treeNode* root,ElemType data);
treeNode* findnode(treeNode* root,ElemType data);
int findleavesnode(treeNode* root);
int calculatedeep(treeNode* root);
 void clearbtree(treeNode* root);


#endif // _CREAT_B_TREE_





#include "bttool.h"

treeNode* creatbtree(treeNode* root,ElemType data)
{
    treeNode* newnode;
    newnode = new treeNode;
    newnode->data = data;
    newnode->tleft = NULL;
    newnode->tright = NULL;

    if(root == NULL)
    {
        root = newnode;
    }
    else
    {
        treeNode* backnode = NULL;
        treeNode* currentnode = root;
        while(currentnode!=NULL)
        {
            backnode = currentnode;
            if(currentnode->data>data)
            {
                currentnode = currentnode->tleft;
            }
            else if(currentnode->data<data)
            {
                currentnode = currentnode->tright;
            }
            else
                delete newnode;
        }

        if(backnode->data>data)
        {
            backnode->tleft = newnode;
        }
        else
        {
            backnode->tright = newnode;
        }
        return root;
    }


}

void preorderbtree(treeNode* root)
{
    treeNode* treenode;
    treenode = new treeNode;
    treenode = root;
    if(treenode == NULL)
    {
        return;
    }
    else
    {
        cout<<treenode->data<<"\t";
        preorderbtree(treenode->tleft);
        preorderbtree(treenode->tright);
    }
    delete treenode;
}

void inorderbtree(treeNode* root)
{
    treeNode* treenode;
    treenode = new treeNode;
    treenode = root;
    if(treenode == NULL)
    {
        return ;
    }
    else
    {
        inorderbtree(treenode->tleft);
        cout<<treenode->data<<"\t";
        inorderbtree(treenode->tright);
    }
    delete treenode;
}

void postorderbtree(treeNode* root)
{
    treeNode* treenode;
    treenode = new treeNode;
    treenode = root;
    if(treenode==NULL)
    {
        return ;
    }
    else
    {
        postorderbtree(treenode->tleft);
        postorderbtree(treenode->tright);
        cout<<treenode->data<<"\t";
    }
    delete treenode;
}

void addtreenode(treeNode* root,ElemType data)
{
    treeNode* newnode;
    newnode = new treeNode;
    newnode->data=data;
    newnode->tleft=NULL;
    newnode->tright=NULL;

    if(root == NULL)
    {
        root = newnode;
        delete newnode;
        return ;
    }
    else
    {
        treeNode* currentnode = root;
        treeNode* backnode = NULL;
        while(currentnode!=NULL)
        {
            backnode = currentnode;
           if(currentnode->data > data)
           {
               currentnode = currentnode->tleft;
           }
           else if(currentnode->data < data)
           {
               currentnode = currentnode->tright;
           }
           else
           {
               //cout<<"this node is exist!!!\n";
               delete newnode;
           }
        }

        if(backnode->data > data)
        {
            backnode->tleft = newnode;
            cout<<"done\n";
        }
        else
        {
            backnode->tright = newnode;
            cout<<"done\n";
        }
        return ;
    }
}


treeNode* findnode(treeNode* root,ElemType data)
{
    treeNode* pnode;
    pnode = new treeNode;
    pnode = root;
    if(pnode == NULL)
    {
        return NULL;
    }
    else
    {
        if(pnode->data==data)
            return pnode;
        else
        {
            if(pnode->data>data)
                return findnode(pnode->tleft,data);
            else
                return findnode(pnode->tright,data);
            return NULL;
        }
    }
    delete pnode;
}

int findleavesnode(treeNode* root)
{
    static int node_count=0;
    treeNode* pnode;
    pnode = new treeNode;
    pnode = root;
    if(pnode == NULL)
    {
        return node_count;
    }
    else
    {
        if(pnode->tleft == NULL &&  pnode->tright == NULL)
        {
            cout<<pnode->data<<endl;
            node_count++;
        }
        else
        {
            findleavesnode(pnode->tleft);
             findleavesnode(pnode->tright);
        }
        return node_count;
    }
}

 int calculatedeep(treeNode* root)
 {
     treeNode* pnode;
     pnode = new treeNode;
     pnode = root;
     int dpleft = 0;
     int dpright = 0;
     if(pnode == NULL)
     {
         return 0;
     }
     else
     {
         dpleft = calculatedeep(pnode->tleft);
         dpright = calculatedeep(pnode->tright);
     }
     if(dpleft>dpright)
     {
         return ++dpleft;
     }
     else
     {
         return ++dpright;
     }
 }


 void clearbtree(treeNode* root)
 {
     if(root)
     {
         clearbtree(root->tleft);
         clearbtree(root->tright);
         delete root;
     }
 }