Haga el programa para la inserción en un árbol B+

Código
/* En este programa se encuentran las rutinas que };
insertan y */
struct componente {
/* retiran llaves de un arbol b+ de cualquier orden.
*/ pagina *s;

int v;

#include "stdio.h" };

//#include "alloc.h"

#include "stdlib.h" struct LIFO1 {

#include "conio.h" int t;

#define N 2 componente a [MAXIMO];

#define M 4 };

#define M1 5

#define MAXIMO 10

#define localizar (pagina *) malloc (sizeof

(pagina)) int main()

{
using namespace std; pagina *raiz,*VSAM;

int x,min,s;
typedef struct z pagina; void ins_b (pagina **raiz,pagina **VSAM,int
typedef struct LIFO LIFO; x,int *s);

typedef struct componente componente; void listar_VSAM (pagina *VSAM);

typedef struct LIFO1 LIFO1; int retira_b (pagina **raiz,

struct z { pagina **VSAM, int x, int *s);

int cont; void listar_b (pagina *p);

int info [M]; int lea();

pagina *apunt [M1]; raiz = VSAM = NULL;

}; printf ("Comienzo..\n");

struct LIFO { printf ("De llave\n");

int t; min = lea();

pagina *a [MAXIMO]; while (min != 9999) {

 ins_b (&raiz, &VSAM, min, &s); }

if (s == 1)

printf ("La llave ya existe en el arbol void init_pila (struct LIFO *p)
B+\n");
{
/*printf ("\n");
p->t = 0;
listar_b (raiz,0);
}
printf ("\n");

listar_VSAM (VSAM);*/
int pila_vacia (struct LIFO *p)
printf ("De llave\n");
{
min = lea();
return (!p->t);
}
}
listar_VSAM (VSAM);

getch();

printf ("\nRetiros\n");
void ins_pila (struct LIFO *p,pagina *s)
printf ("De llave a retirar\n");
{
x = lea();
if (p->t == MAXIMO) {
while (x != 9999) {
printf ("la pila no soporta mas elementos\n");
retira_b (&raiz, &VSAM, x, &s);
exit (1);
if (s == 0)
}
printf ("La llave no existe en el arbol
B+\n"); else {

listar_b (raiz); p->t++;

printf ("\n"); p->a [p->t - 1] = s;

listar_VSAM (VSAM); }

printf ("De llave a retirar\n"); }

x = lea();

} void retira_pila (struct LIFO *p,pagina **s)

printf ("\n"); {

listar_b (raiz); if (pila_vacia (p) ) {

getch(); printf ("la pila esta vacia\n");

return 0; exit (1);

}
 else { {

*s = p->a [p->t - 1]; if (pila1_vacia (p) ) {

p->t--; printf ("la pila esta vacia\n");

} exit (1);

} }

else {

*s = p->a [p->t -1].s;

void init1_pila (struct LIFO1 *p) *i = p->a [p->t - 1].v;

{ p->t--;

p->t = 0; }

} }

int pila1_vacia (struct LIFO1 *p)

return (!p->t); void inicializar (pagina *p)

} {

int i;

void ins1_pila (struct LIFO1 *p,pagina *s,int i)

{ i=0;

if (p->t == MAXIMO) { p->cont = 0;

printf ("la pila no soporta mas elementos\n"); while (i < M1)

exit (1); p->apunt [i++] = NULL;

} }

else {

p->t++; void crear_pagina (pagina **p,int x)

p->a[p->t - 1].s = s; {

p->a[p->t - 1].v = i; *p = localizar;

} inicializar (*p);

} (*p)->cont = 1;

(*p)->info [0] = x;

void retira1_pila (struct LIFO1 *p,pagina **s,int }

*i)
void buscar (pagina *p,int x,int *posicion,LIFO else {
*pila)
j = p->cont - 1;
{
while (j >= *i) {
int i,encontro = 0;
p->info [j+1] = p->info [j];

j--;
*posicion = -1;
}
while (p && !encontro) {
}
ins_pila (pila, p);
p->cont++;
i = 0;
p->info [*i] = x;
while (x > p->info [i] && i < p->cont - 1)
}
i++;

if (x < p->info [i])

int donde (pagina *p, int x)
p = p->apunt [i];
{
else if (x > p->info [i])
int i;
if (p->apunt [0] != NULL)

p = p->apunt [i+1];
i= 0;
else p = NULL;
while (x > p->info [i] && i < p->cont - 1)
else if (p->apunt [0] != NULL)
i++;
p = p->apunt [i+1];
return (i);
else encontro = 1;
}
}

if (!encontro)
void romper (pagina *p,pagina *t,pagina **q,
*posicion = i;
int x,int *subir,int separar)
}
{

int a [M1], i=0 ,s = 0;

void insertar (pagina *p,int x,int *i)
pagina *b[M1+1], *temp;
{

int j;
if (separar == 0) {

temp = p->apunt [M];

if (p->cont)
p->apunt[M] = NULL;
if (x > p->info [*i])
}
(*i)++;
while (i < M && !s)
 if (p->info[i] < x) { else {

a[i] =p->info [i]; p->cont = (*q)->cont = N;

b[i] = p->apunt [i]; while (i < N) {

p->apunt [i++] = NULL; p->info [i] = a[i];

} p->apunt [i] = b [i];

else s = 1; (*q)->info [i] = a[i+N+1];

a[i] = x; (*q)->apunt [i] = b[i+N+1];

b[i] = p->apunt [i]; i++;

p->apunt [i] = NULL; }

b[++i] = t; }

while (i <= M) { p->apunt [N] = b [N];

a[i] =p->info [i-1]; (*q)->apunt [N] = b [M1];

b[i+1] = p->apunt [i]; *subir = a [N];

p->apunt [i++] = NULL; }

*q = localizar; void cderecha_apunt (pagina *p,int i)

inicializar (*q); {

i = 0; int j;

if (separar == 0) {

p->cont = N; j = p->cont;

(*q)->cont = N + 1; while (j > i) {

(*q)->info [0] = a[N]; p->apunt [j] = p->apunt [j - 1];

while (i < N) { j--;

p->info [i] = a[i]; }

p->apunt [i] = b [i]; }

(*q)->info [i+1] = a[i+N+1];

(*q)->apunt [i] = b[i+N+1]; void listar_b (pagina *p)

i++; {

} int i;

(*q)->apunt [M] = temp; LIFO1 pila;

p->apunt [M] = *q;

} init1_pila (&pila);
 while (p) { listar1_b (p->apunt [i], l+1);

ins1_pila (&pila,p,0); }

p = p->apunt [0]; }

while (!pila1_vacia (&pila) ) { void listar_VSAM (pagina *VSAM)

retira1_pila (&pila,&p,&i); {

if (i < p->cont) { int i;

printf ("%d ",p->info [i]);

ins1_pila (&pila,p,i+1); while (VSAM != NULL ) {

if (p->apunt [0] != NULL) i = 0;

p = p->apunt [i+1]; while (i < VSAM->cont)

else p = NULL; printf ("%d ",VSAM->info[i++]);

while (p) { printf ("/");

ins1_pila (&pila,p,0); VSAM = VSAM->apunt[M];

p = p->apunt [0]; }

} printf ("\n");

} }

} void ins_b (pagina **raiz,pagina **VSAM,int

x,int *s)

{
void listar1_b (pagina *p,int l)
int posicion,i,subir,subir1,terminar,separar;
{
pagina *p,*nuevo,*nuevo1;
int i;
LIFO pila;

if (p) {
init_pila (&pila);
for (i = 0; i < l; i++)
*s = 0;
printf (" ");
if (*raiz == NULL) {
for (i = 0; i < p->cont; i++)
crear_pagina (raiz, x);
printf ("%4d",p->info [i]);
*VSAM = *raiz;
printf ("\n");
}
listar1_b (p->apunt [0],l+1);
else {
for (i=1; i <= p->cont; i++)
 buscar (*raiz, x, &posicion, &pila); if (separar == 1 && terminar == 0) {

if (posicion == -1) crear_pagina (raiz,subir);

*s = 1; /* La llave esta en el arbol */ (*raiz)->apunt [0] = p;

else { (*raiz)->apunt [1] = nuevo;

terminar = separar = 0; }

while (!pila_vacia (&pila) && terminar == }

0) {
}
retira_pila (&pila, &p);
}
if (p->cont == M) {

if (separar == 0) {
int lea()
romper (p, NULL, &nuevo, x,
&subir,separar); {

separar = 1; char a[10];

else { gets (a);

romper (p,nuevo,&nuevo1,subir, return (atoi(a));

&subir1,separar); }

subir = subir1;

nuevo = nuevo1; void retirar (pagina *p,int i)

} {

} while (i < p->cont - 1) {

else { p->info [i] = p->info [i+1];

if (separar == 1) { i++;

separar = 0; }

i = donde (p, subir); p->cont--;

insertar (p, subir, &i); }

cderecha_apunt (p, i+1);

p->apunt [i+1] = nuevo; void cambio (pagina *p,pagina *q,pagina *r,int

i,int x)
}
{
else insertar (p, x,&posicion);
int k,t;
terminar = 1;

}
if (x > r->info [r->cont - 1]) {
}
 t = q->info [i]; while (p->apunt [j] == NULL && j < p->cont -
1)
retirar (q,i);
j++;
k = 0;
return (p->apunt [j] == NULL);
insertar (p,t,&k);
}
t = r->info [r->cont - 1];

retirar (r, r->cont - 1);

void cizquierda_apunt (pagina *p,int i,int j)
k = i;
{
if (k == -1)
while (i < j) {
k = 0;
p->apunt [i] = p->apunt [i+1];
insertar (q,t,&k);
i++;
}
}
else {
p->apunt [i] = NULL;
t = q->info [i];
}
retirar (q, i);

k = p->cont - 1;
void esta (pagina *p, int x, int *posicion, LIFO1
if (k == -1) *pila)
k = 0; {
insertar (p,t,&k); int i = 0,encontro = 0;
t = r->info [0];

retirar (r, 0); *posicion = -1;

k = i; while (p != NULL && !encontro) {
if (q->cont != 0) i = 0;
if (k > q->cont - 1) while (x > p->info [i] && i < p->cont - 1)
k = q->cont -1; i++;
insertar (q,t,&k); if (x < p->info [i]) {
} ins1_pila (pila, p, i);
} p = p->apunt [i];

}
int hoja (pagina *p) else if (x > p->info [i]) {
{ ins1_pila (pila, p, i+1);
int j = 0; if (p->apunt [0] != NULL)

p = p->apunt [i+1];
 else p = NULL; cambio (r, q, p, i, x);

} r->apunt [r->cont] = p->apunt [0];

else { cizquierda_apunt (p, 0, p->cont + 1);

if (p->apunt [0] != NULL) { terminar = 1;

ins1_pila (pila, p, i+1); }

p = p->apunt [i+1]; else if (p->cont < N && r->cont > N) {

} cambio (p, q, r, i, x);

else { cderecha_apunt (p, 0);

ins1_pila (pila, p, i); p->apunt [0] = r->apunt [r->cont + 1];

encontro = 1; r->apunt [r->cont + 1] = NULL;

} terminar = 1;

} }

} else {

if (encontro == 1) j = r->cont;

*posicion = i; if (r->apunt [0] == NULL) /* Si es ultimo

nivel */
}
r->apunt [M] = p->apunt [M];

else r->info [j++] = q->info [i];

void unir (pagina **raiz, pagina *q, pagina *r,
pagina *p, k = 0;

int i, LIFO1 pila, int x, int posicion) while (k <= p->cont - 1)

{ r->info [j++] = p->info [k++];

int terminar = 0,j, k; r->cont = j;

pagina *t; retirar (q, i);

k = 0;

retirar (p, posicion); j = M - p->cont;

if (x < r->info [0]) { while (p->apunt [k] != NULL)

t = p; r->apunt [j++] = p->apunt [k++];

p = r; free (p);

r = t; if (q->cont == 0) {

} q->apunt [i+1] = NULL;

while (terminar == 0) { if (pila1_vacia (&pila) ) {

if (r->cont < N && p->cont > N) { free (q);

 q = NULL; int retira_b (pagina **raiz, pagina **VSAM, int x,
int *s)
}
{
}
int posicion, i, k, temp;
else cizquierda_apunt (q, i+1, q->cont+1);
pagina *p, *q, *r;
if (q != NULL)
LIFO1 pila;
if (q->cont >= N)

terminar = 1;
*s = 1;
else {
init1_pila (&pila);
t = q;
esta (*raiz, x, &posicion, &pila);
if (!pila1_vacia (&pila) ) {
if (posicion == -1) {
retira1_pila (&pila, &q, &i);
*s = 0; /* La llave no existe en el arbol */
if (x >= q->info [0]) {
return (0);
p = t;
}
r = q->apunt [i-1];
retira1_pila (&pila, &p, &i);
i--;
if (p->cont > N) {
}
retirar (p, posicion);
else {
return (1);
r = t;
}
p = q->apunt [i+1];
if (pila1_vacia (&pila)) {
}
retirar (p, posicion);
}
if (p->cont == 0) {
else terminar = 1;
free (*raiz);
}
*raiz = *VSAM = NULL;
else {
}
terminar = 1;
return (1);
*raiz = r;
}
}
retira1_pila (&pila, &q, &i);
}
if (i < q->cont) {
}
r = q->apunt [i+1];
}
if (r->cont > N) {

retirar (p, posicion);

 temp = r->info[0]; retirar(r,r->cont - 1);

retirar(r,0); retirar (q,i-1);

retirar (q,i); k = donde (p, temp);

k = donde (p, temp); insertar (p, temp, &k);

insertar (p, temp, &k); k = donde (q, temp);

k = donde (q, r->info [0]); insertar (q, temp, &k);

insertar (q, r->info [0], &k); return (1);

return (1); }

} }

} if (i > 0)

if (i > 0) { i--;

r = q->apunt [i-1]; unir (raiz,q,r,p,i,pila,x,posicion);

if (r->cont > N) { return (1);

retirar (p, posicion); }

temp = r->info [r->cont - 1];

Ejecución
Inserción

Eliminación