CODIGO FUENTE DEL PROGRAMA DE ARBOL B

#include <iostream>
#define MAX 100
#include <conio.h>
#include <bits/stdc++.h>
using namespace std;
class node;
struct p_nodo
{
node *next;
int key;
};
class node//ARRAY DE NODOS
{
public:
int noofkeys;
p_nodo data[MAX];
node *father;
node *first;
node();
CLASE
int leafnode();
void insertinanode(p_nodo x);
p_nodo splitanode(p_nodo x);
node *nextindex(int x);
void display();
};

//BIBLIOTECAS

//ESTRUCTURA PRINCIPAL
//SIGUIENTE DE NODO
//VALOR DEL NODO
//CLASE NODO

//FUNCIONES DE LA

void node::display()
//FUNCION MOSTRAR
{
int i;
//DECLARA VARIABLE I;
cout<<"(";
for(i=0;i<noofkeys;i++)
cout<<data[i].key<<" ";
//LLAVES PARA LOS
NODOS
cout<<")";
}
node *node::nextindex(int x)

//FUNCION PARA EL ORDENAMIENTO

DE LOS NODOS

{
int i;
if(x<data[0].key)
return(first);
for(i=0;i<noofkeys ;i++)
NODOS

//ORDENAMIENTO DE LOS
DESDE EL PRIMERO AL

ULTIMO
if(x <= data[i].key)
return data[i-1].next;

return data[i-1].next; }
int node::leafnode()
{
if(data[0].next==NULL)

//FUNCION QUE VERIFICA SI EL

NODO ES HOJA

return 1;
return 0;
}
void node::insertinanode(p_nodo x)

//FUNCION INSERTAR NODO

ORDENADAMENTE

{
int i;
// ENTERO I
for(i=noofkeys-1;i>=0 && data[i].key>x.key;i--)
//BUCLE PARA EL
ORDENAMIENTO DE LOS
NODOS SEGN SU DATO
data[i+1]=data[i];
//RECORRIDO DE LOS NODOS
data[i+1]=x;
noofkeys++;
}
p_nodo node::splitanode(p_nodo x)
NODO
{
node *T;
p_nodo myp_nodo;
int i,j,centre;
centre=(noofkeys-1)/2;

//FUNCION PARA DIVIDIR EL

//CREA NODO T
//VARIABLES

T=new node;
// T NUEVO NODO
if(x.key>data[centre].key) {
//DIVIDE EL NODO EN DOS
PARTES
for(i=centre+1,j=0;i<=noofkeys;i++,j++)
T->data[j]=data[i];
T->noofkeys=noofkeys-centre-1;
//BUCLE PARA
DIVIDIR LOS NODOS
noofkeys=noofkeys-T->noofkeys;
T->insertinanode(x);
T->first=T->data[0].next;
T->father=father;
myp_nodo.key=T->data[0].key;
myp_nodo.next=T;
//ELIMINA EL NODO T
for(i=1;i<T->noofkeys;i++)
T->data[i-1]=T->data[i];
T->noofkeys--;
}
else
{
for(i=centre,j=0;i<noofkeys;i++,j++)

//RECORRIDO DE LOS
NODOS DIVIDIDOS

T->data[j]=data[i];
T->noofkeys=noofkeys-centre;
noofkeys=noofkeys-T->noofkeys;
insertinanode(x);
T->father=father;
myp_nodo.key=T->data[0].key;
myp_nodo.next=T;

//SI EL DATO ES
MAYOR QUE EL CENTRO
SUBE A PADRE

//INSERTA EL PADRE EN
UNA NUEVO NODO Y
RETORNA EL PADRE

for(i=1;i<T->noofkeys;i++)
T->data[i-1]=T->data[i];
T->noofkeys--;
}
return(myp_nodo);
}
node::node(){
for(int i=0;i<=MAX;i++)
data[i].next=NULL;
//CONSTRUCTOR PARA
QUE EL NODO INICIE EN
NULL
noofkeys=0;
father=NULL;
first=NULL;
}
class Q {
node *data[60];
int R,F;
public:
Q()
{
R=F=0;
}
int empty()
{
if(R==F)
return 1;
else
return 0;
}
node *deque()
{
return data[F++];
}
void enque(node *x)
{
data[R++]=x;
}
void makeempty()
{

R=F=0;
}
};
class btree
int mkeys;
node *root;
public:
btree(int n)
{
mkeys=n;
root=NULL;
}
void insert(int x);
void displaytree();

//MAXIMO NUMERO DE ELEMENTOS

EN UN NODO
//CREA UN NODO TEMPORAL

//FUNCIONES DE LA CLASE

};
void btree::displaytree()
{
Q q1,q2;
node *p;

//FUNCION PARA
MOSTRAR EL
ARBOL
EN GRAFICA EN
LA PANTALLA

q1.enque(root);
while(!q1.empty())
{
q2.makeempty();
cout<<"\n";
while(!q1.empty())
{
p=q1.deque();
p->display();cout<<" ";
if(!p->leafnode())
{
q2.enque(p->first);
for(int i=0;i<p->noofkeys;i++)
q2.enque(p->data[i].next);
}
}
q1=q2;
}
}
void btree::insert(int x)
{
int index;
p_nodo myp_nodo;
node *p,*q;

//FUNCION PARA INSERTAR NODO

//CREA VARIABLE ENTERA
//RETORNA EL PRIMERO
//CREA DOS NODOS P Y Q

myp_nodo.key=x;
myp_nodo.next=NULL;
if(root==NULL)
{

//NODO SU DATO X
//SIGUIENTE NULL
//SI ROOT ES IGUAL NULL

root = new node;

//ROOT NUEVO NODO

root->insertinanode(myp_nodo);

//ROOT INSERTA EN EL

ARBOL
}
else
{
p=root;
while(!(p->leafnode()))
p=p->nextindex(x);

//SINO ROOT ES EL PADRE

if(p->noofkeys<mkeys)
p->insertinanode(myp_nodo);
else
{
myp_nodo=p->splitanode(myp_nodo);
while(1)
{
if(p==root)
{
q=new node;
q->data[0]=myp_nodo;
q->first=root;

//SI P ES IGUAL A NULL

//Q NUEVO NODO
//DATO DE Q
//Q PRIMERO IGUAL A

ROOT
q->father=NULL;

//PADRE IGUAL A

NULL
q->noofkeys=1;

//NUMERO DE DATOS EN
EL NODO
//ROOT IGUAL A Q

root=q;
q->first->father=q;
q->data[0].next->father=q;
return;

//RECORRIDO DE Q

}
else
{
p=p->father;
if(p->noofkeys < mkeys)
{
p->insertinanode(myp_nodo);
return;
}
else
myp_nodo=p->splitanode(myp_nodo);
}
}
}

}
}
int main()
{
int n,i,x,op;
//DECLARACION DE VARIABLES
node *p;
//DECLARACION DE NODO
cout<<"\NUMERO MAXIMO DE NUMEROS EN UN NODO ? :"; //IMPRIMIR
cin>>n;
//DATO A PEDIR
btree b(n);
//DECLARACION DEL OBJETO DE LA
CLASE BTREE
do
{
cout<<"\n\n1)Grafica de 20 elementos\n2)Salir"; //OPCIONES
DE PANTALLA
cout<<"\nIngrese una opcion : ";
// OPCION A
INGRESAR
cin>>op;
//OPCION RECIBIDA
switch(op)
{
case 1:
//CASO 1 PARA 20 ELEMENTOS
for(int i = 0; i < 21; i++) //BUCLE PARA 20
ELEMENTOS
b.insert(i);
//FUNCION DE INSERTAR
cout<<"\nGrafica del arbol : "; //SALIDA DE TEXTO
b.displaytree();
//FUNCION
MOSTRAR ARBOL
break;
}
}while(op!=2);
return 0;
}

//CASO SALIR