B+数的插入实现

#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <cmath>
#include <limits>
using namespace std;
//徐
struct TreeNode
{
    int maxlength;
    int *data;
    TreeNode **nodes;
    bool endpoint;
    int index;
    
    TreeNode(int size)
    {
      cout<<"constructor"<<endl;
      index = -1;           
      maxlength = size-1;
      data = new int[size];
      nodes = new TreeNode *[size+1];
      for(int i=0;i<size+1;i++)
      nodes[i] = NULL;
      endpoint = true;
    }
    
    void insertvalue(int value)
    {
         int position = findinsertposition(value);
        
         for(int i=index;i>=position;i--)
         data[i+1] = data[i];
         
         data[position] = value;
         
         index++;
         
    }
    
    
    
    void printdata()
    {
       for(int i=0;i<=index;i++)
       cout<<"the value is :"<<data[i]<<endl;
    }
    
    int findinsertposition(int value)
    {
       int result = 0;
       for(int i=0;i<=index;i++)
       {
          if(value > data[i])
          result++;
          else
          break;
       }
       
       return result;
    }
    
    bool findvalue(int value)
    {
      for(int i=0;i<=index;i++)
      {
        if(value == data[i])
        return true;
      }
      
      return false;
    }
    
    void insertnode(int value,TreeNode *first,TreeNode *second)
    {
       int position = findinsertposition(value);
        for(int i=index+1;i>=position+1;i--)
        nodes[i+1] = nodes[i];
        
        nodes[position] = first;
        nodes[position+1] = second;
        
        insertvalue(value);
       
    }
    
    ~TreeNode()
    {
      cout<<"distructor"<<endl;         
      delete[] data;
      delete[] nodes;
    }
    
    bool canSplit()
    {
       return (index+1) > maxlength;
    }
    
    
    void split(int &value,TreeNode *&first,TreeNode *&second)
    {
         int position = maxlength/2;
         
         value = data[position];
             
         first = new TreeNode(3);
         first->endpoint = endpoint;
         for(int i=0;i<position;i++)
         first->insertvalue(data[i]);
         for(int i=0;i<position+1;i++)
         first->nodes[i] = nodes[i];
         
         
         second = new TreeNode(3);
         second->endpoint = endpoint;
         for(int i= position+1;i<=index;i++)
         second->insertvalue(data[i]);
         for(int i= position+1;i<=index+1;i++)
         second->nodes[i-position-1] = nodes[i];
         
    }
    
       
};

struct TempNode
{
       int value;
       struct TreeNode *littletree;
       struct TreeNode *largetree;
};

class BTree
{
public:
      void insertnode(TreeNode *&root,int value,TempNode &temp,bool &flag,int &depth)
      {
          depth++;
           
         if(root == NULL)
         {
            root = new TreeNode(3);
            root->insertvalue(value);
            flag = false;
            depth--;
            return;
         }
         else
         {
            if(root->findvalue(value))
            {
               flag = false;
               depth--;
               return;
            }
            else
            {
                if(root->endpoint == true)
                {
                    root->insertvalue(value);
                    flag = false;
                    if(root->canSplit())
                    {
                       root->split(temp.value,temp.littletree,temp.largetree);
                       flag = true;
                       delete root;
                       root =  NULL;
                       if(depth == 1)
                       {
                          if(root == NULL)
                          {
                             root = new TreeNode(3);
                             root->endpoint = false;
                             root->insertvalue(temp.value);
                             root->nodes[0] = temp.littletree;
                             root->nodes[1] = temp.largetree;
                          }
                       }
                    }
                    depth--;
                    return;
                }
                else
                {
                   int position = root->findinsertposition(value);
                   TreeNode *child = root->nodes[position];
                   insertnode(child,value,temp,flag,depth);
                   
                   if(flag == true)
                   {
                      root->insertnode(temp.value,temp.littletree,temp.largetree);
                      flag = false;
                      if(root->canSplit())
                      {
                         root->split(temp.value,temp.littletree,temp.largetree);
                         flag = true;
                         delete root;
                         root = NULL;
                         if(depth == 1)
                         {
                            if(root == NULL)
                            {
                              root = new TreeNode(3);
                              root->endpoint = false;
                              root->insertvalue(temp.value);
                              root->nodes[0] = temp.littletree;
                              root->nodes[1] = temp.largetree;
                            }
                         }
                      }
                   }
                   
                   
                   depth--;
                   return;
                }
            }
         }
      } 
      
      
      void printdata(TreeNode *root)
      {
          stack<TreeNode *> st; 
          stack<TreeNode *> tempst; 
         if(root != NULL)
         {
            st.push(root);
            while(!st.empty())
            {
               TreeNode *node = st.top();
               st.pop();
               
               node->printdata();
               for(int i=0;i<=node->index+1;i++)
               {
                  if(node->nodes[i] != NULL)
                  tempst.push(node->nodes[i]);
               }
               
               while(!tempst.empty())
               {
                 st.push(tempst.top());
                 tempst.pop();
               }
               
            }
         }
      }
      
      void deleteallnode(TreeNode *root)
      {
        stack<TreeNode *> st;
        if(root != NULL)
        {
           st.push(root);
           
           while(!st.empty())
           {
              TreeNode *node = st.top();
             
              st.pop();
              for(int i=0;i<=node->index+1;i++)
              {
                if(node->nodes[i] != NULL)
                st.push(node->nodes[i]);
              }
              
              delete node;
           }
        }
      }
      
      
};




int main(int argc, char *argv[])
{    

    BTree tree;
    
    TreeNode *root = NULL;
    bool flag = false;
    int depth = 0;
    TempNode tempnode;
    
    tree.insertnode(root,45,tempnode,flag,depth);
    tree.insertnode(root,24,tempnode,flag,depth);
    tree.insertnode(root,53,tempnode,flag,depth);
    tree.insertnode(root,90,tempnode,flag,depth);
    tree.insertnode(root,3,tempnode,flag,depth);
    tree.insertnode(root,12,tempnode,flag,depth);      
    tree.insertnode(root,37,tempnode,flag,depth); 
     tree.insertnode(root,50,tempnode,flag,depth);
      tree.insertnode(root,61,tempnode,flag,depth);
       tree.insertnode(root,70,tempnode,flag,depth);
        tree.insertnode(root,100,tempnode,flag,depth);
    
    if(root != NULL)
    tree.printdata(root);
    tree.deleteallnode(root);
     
    system("PAUSE");
    return EXIT_SUCCESS;
}