¿Mejor algoritmo? Problema con aproximaciones de Grafos

[AlbertoBSD]

La raiz es el primer nodo que se inserta..

Su padre es null.

Tus funciones de inOrden o preorden son recursivas y no necesitan saber quien es el padre, aun asi gastan mas memoria. En funciones iterativas es mecesario saber quien es el podre y gastan menos memoria.

En ocasiones es necesario separar subarboles o eliminar arboles completos, y tambien facilita mucho tener una referencia al padre.

Basicamente es una facilidad tener esa referencia en fumciones iterarivas.

Como reto deberias de hacer tu funcion inOrden y preOrden de forma iterativa, Esto es sin llamar a las funciones dichas desde si mismas.

Saludos!

[do-while]

Interesante ejercicio.

Se trata de crear particiones sobre el conjunto de personas (tenemos una relación de equivalencia en un conjunto->la equivalencia crea una partición del conjunto (un conjunto de subconjuntos disjuntos)).

Se me ocurre que se puede tener un vector (mejor árbol, que así no hay que estar desplazando valores para mantener el orden después de una inserción) con pares del tipo numero_persona-clase. Así la cuestión de decidir si dos personas son amigos se reduce a realizar la búsqueda de las dos personas y ver si pertenecen a la misma clase, y la inserción se podría hacer en un vector (sabemos que el máximo numero de parejas es 100.000 / 2) en el que cada componente sea un vector de punteros a los nodos del árbol que formen parte de la misma clase. Así, a través de los punteros de la tabla, si hubiese que fusionar dos clases sería muy fácil corregir directamente en cada nodo del árbol la clase a la que pertenece el par persona-clase. La tabla mantiene una lista de todas las personas relacionadas entre sí y soluciona el problema de buscar en el árbol todas las personas que pertenecen a la misma clase.

A ver que sale de esta idea.

¡Saludos!


Con el planteamiento anterior, cambiando la idea de un vector de vectores por la de un vector de árboles, en mi ordenador, el tiempo de ejecución en el caso de la entrada de mayor dimensión se pasa del segundo por poco. Entre 1'2 y 1'3 segundos.

Alberto, te mando el código por MP, como los planteamientos son distintos me gustaría ver tu código.

¡Saludos!

[AlbertoBSD]

   

Excelente aproximacion. Aun no veo tu codigo pero.... la idea es genial y de hecho es mas rápido que un Grafo con Disjktra...

Fucionar arboles seria mas rapido y las consultas prácticamente ya están hechas al tener un valor que nos indiqué a que conjunto o "arbol" pertenece un nodo facilmente se puede saber si existe ese lazo o no.

En lo que llegue al trabajo te pado mi codigo.

Saludos

[do-while]

Bueno... hoy estoy muy tonto. Pensaba que en los códigos anteriores discutíais sobre opciones para resolver el problema. Veo que ya hay alguna solución, así que dejo la mía también. main está al final y justo antes están las funciones problema_interactivo y problema_aleatorio. La primera solicita los datos desde el teclado, la segunda genera 100.000 casos aleatorios y los procesa.

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define DIM 100000

struct Persona
{
int valor;
int clase;
};
typedef struct Persona Persona;

struct NodoArbolPersona
{
Persona *persona;

struct NodoArbolPersona *menores, *mayores;
};
typedef struct NodoArbolPersona NodoArbolPersona;

void insertar(NodoArbolPersona **arbol, Persona *persona)
{
if(!(*arbol))
{
(*arbol) = malloc(sizeof(NodoArbolPersona));
(*arbol)->persona = persona;
(*arbol)->menores = NULL;
(*arbol)->mayores = NULL;

return;
}

if(persona->valor < (*arbol)->persona->valor)
insertar(&((*arbol)->menores), persona);
else
insertar(&((*arbol)->mayores), persona);
}

Persona* buscar(NodoArbolPersona *arbol, int valor)
{
if(!arbol)
return NULL;

if(arbol->persona->valor == valor)
return arbol->persona;

if(valor < arbol->persona->valor)
return buscar(arbol->menores, valor);

return buscar(arbol->mayores,valor);
}

void cambiar_clase(NodoArbolPersona *amigos, int nueva_clase)
{
if(!amigos)
return;

amigos->persona->clase = nueva_clase;

cambiar_clase(amigos->menores, nueva_clase);
cambiar_clase(amigos->mayores, nueva_clase);
}

void fusionar_arboles(NodoArbolPersona **destino, NodoArbolPersona *origen)
{
if(!(*destino))
*destino = origen;

if((*destino)->persona->valor == origen->persona->valor)
return;

if(origen->persona->valor < (*destino)->persona->valor)
fusionar_arboles(&((*destino)->menores),origen);
else
fusionar_arboles(&((*destino)->mayores),origen);

}

void insertar_amigos(NodoArbolPersona *amigos[DIM/2], NodoArbolPersona **personas, int a, int b)
{
Persona *persona1,*persona2, *aux;
int i,clase_aux;

if((persona1 = buscar(*personas,a)))
{
if((persona2 = buscar(*personas,b))) //ambas personas existen
{
if(persona1->clase != persona2->clase)
{
//pertenecen a distintas clases y hay que fusionarlas
if(persona1->clase > persona2->clase)
{
aux = persona2;
persona2 = persona1;
persona1 = aux;
}

clase_aux = persona2->clase;
cambiar_clase(amigos[persona2->clase],persona1->clase); //cambiamos toda la clase b para que apunte a a.
fusionar_arboles(&(amigos[persona1->clase]),amigos[clase_aux]); //añadimos toda el arbol b a a.
amigos[clase_aux] = NULL;
}
}
else //existe p1, pero no p2
{
persona2 = malloc(sizeof(Persona));

persona2->valor = b;
persona2->clase = persona1->clase;

insertar(personas, persona2);
insertar(&(amigos[persona1->clase]), persona2);
}
}
else //persona1 no existe
{
if((persona2 = buscar(*personas,b)))
{
//existe p2 pero no p1
persona1 = malloc(sizeof(Persona));

persona1->valor = a;
persona1->clase = persona2->clase;

insertar(personas, persona1);
insertar(&(amigos[persona2->clase]), persona1);
}
else //no existen ninguna de las dos personas
{
//buscamos la primera clase que este vacia
for(i = 0 ; amigos[i] ; i++);

//creamos las personas:
persona1 = malloc(sizeof(Persona));
persona2 = malloc(sizeof(Persona));

persona1->valor = a;
persona2->valor = b;
persona1->clase = persona2->clase = i;

insertar(personas,persona1);
insertar(personas,persona2);

insertar(&(amigos[i]),persona1);
insertar(&(amigos[i]),persona2);

}
}

return;
}

//tenemos dos funciones para liberar la memoria de los arboles
//la unica diferencia es que la primera libera el dato "persona"
//y la segunda no.
void destruir_personas(NodoArbolPersona **personas)
{
if(!(*personas))
return;

destruir_personas(&((*personas)->menores));
destruir_personas(&((*personas)->mayores));

free((*personas)->persona);
free(*personas);

*personas = NULL;
}

void destruir_clase(NodoArbolPersona **amigos)
{
if(!(*amigos))
return;

destruir_personas(&((*amigos)->menores));
destruir_personas(&((*amigos)->mayores));

free(*amigos);

*amigos = NULL;
}

void problema_interactivo()
{
//cada componente del vector es un arbol que relaciona los amigos que forman una "clase"
NodoArbolPersona *clases[DIM / 2], *personas = NULL; //personas: arbol de elementos valor-clase
Persona *persona1, *persona2;
int num_personas, num_casos, amigo1, amigo2;
char operador;

for(num_personas = 0 ; num_personas < DIM / 2 ; num_personas++)
clases[num_personas] = NULL;

scanf("%d", &num_personas);
scanf("%d", &num_casos);
while(getchar() != '\n');

while(num_casos--)
{
scanf("%c%d%d", &operador, &amigo1, &amigo2);
while(getchar() != '\n');

switch(operador)
{
case 'S':
insertar_amigos(clases, &personas,amigo1, amigo2);
break;

case 'P':
if((persona1 = buscar(personas,amigo1)) && (persona2 = buscar(personas,amigo2)))
{
if(persona1->clase == persona2->clase)
printf("1\n");
else
printf("0\n");
}
else
printf("0\n");
}
}

destruir_personas(&personas);

for(num_personas = 0 ; num_personas < DIM / 2 ; num_personas++)
destruir_clase(&(clases[num_personas]));
}

void problema_aleatorio()
{
//cada componente del vector es un arbol que relaciona los amigos que forman una "clase"
NodoArbolPersona *clases[DIM / 2], *personas = NULL; //personas: arbol de elementos valor-clase
Persona *persona1, *persona2;
int num_personas, num_casos = DIM, amigo1, amigo2;
char operador;
char entrada[20];

srand(time(NULL));

for(num_personas = 0 ; num_personas < DIM / 2 ; num_personas++)
clases[num_personas] = NULL;

while(num_casos--)
{
//vamos a forzar a que, aproximadamente, el 60% de los casos sean saludos
sprintf(entrada,"%c %d %d",rand() % 10 < 6 ? 'S' : 'P', rand() % (DIM + 1), rand() % (DIM + 1));
sscanf(entrada,"%c%d%d", &operador, &amigo1, &amigo2);

switch(operador)
{
case 'S':
insertar_amigos(clases, &personas,amigo1, amigo2);
break;

case 'P':
if((persona1 = buscar(personas,amigo1)) && (persona2 = buscar(personas,amigo2)))
{
if(persona1->clase == persona2->clase)
printf("1\n");
else
printf("0\n");
}
else
printf("0\n");
}
}

destruir_personas(&personas);

for(num_personas = 0 ; num_personas < DIM / 2 ; num_personas++)
destruir_clase(&(clases[num_personas]));
}

int main(int argc, char *argv[])
{
//problema_interactivo();
problema_aleatorio();

return 0;
}


[AlbertoBSD]

Hola!

Dejo aqui mis 2 implementaciones

La primera con Un Grafo y Disjktra simplificado

Y la segunda como lo sugirio do-while con un arbol y una referencia a que arbol/clase/conjunto pertenece cada nodo (Esta última es la mas rapida)

Código (c) [Seleccionar] Expandir

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stdbool.h>
#include<time.h>


#define MAXLINE 40

struct nodo_arbol {
struct nodo_arbol *padre,*derecho,*izquierdo; // 12 u 24 bytes
int valor; // 4 bytes
}; //Total 16 u 28 bytes por Nodo
//peor Caso 28 bytes * 100,000 nodos = ~2.8 MB

struct nodo {
int id; //4 bytes
int *relations; //4 ú 8 bytes
int total; //4 bytes
struct nodo_arbol *arbol; //4 ú 8 bytes
int offset;
int visitado;
}; //Total 16 u 24 bytes por Nodo
///peor Caso 24 bytes * 100,000 nodos = ~2.40 MB

struct nodo **todos = NULL; //Futuro arreglo de todos los nodos existente
//4 y 8 bytes
//Peor caso 8 bytes * 100,000   = ~800 KB

void add_relation(int A,int B);
bool existe_salto(int A,int B);

struct nodo_arbol *crear_nodo_arbol(struct nodo_arbol *padre,int valor);
struct nodo_arbol *buscar_nodo_arbol(struct nodo_arbol *arbol,int valorAbuscar);
struct nodo_arbol *agregar_valor_arbol(struct nodo_arbol *arbol,int valor);


int main() {
FILE *in = NULL;
char *line = NULL;
char *delim = " \n";
char *token;
char caso;
int N,M,i,A,B;
in = fopen("amistad.in","r"); //Archivo ¬¬
srand(time(NULL)); // Para los nodos visitados...
line = calloc(MAXLINE,1);
//Leemos la primera linea
fgets(line,MAXLINE,in);
token = strtok(line,delim);
N = strtol(token,NULL,10);
todos = calloc(sizeof(struct nodo*),N); //Reservamos espacio para al menos N apuntadores a los nodos
token = strtok(NULL,delim);
M = strtol(token,NULL,10);
//Leemos las siguientes M lineas y evaluamos
i = 0;
while(i < M) {
memset(line,0,MAXLINE);
//Leemos la M,esima linea
fgets(line,MAXLINE,in);
token = strtok(line,delim);
caso = token[0];
token = strtok(NULL,delim);
A = strtol(token,NULL,10);
A--;
token = strtok(NULL,delim);
B = strtol(token,NULL,10);
B--;
//Evaluamos
switch(caso){
case 'P':
//printf("P %i %i\n",A+1,B+1);
if(todos[A] && todos[B]) { // Ambos nodos son Validos, entonces hay que buscar si existe al menos un camino de a A a B
if(existe_salto(A,B)) {
printf("1\n");
}
else {
printf("0\n");
}
}
else { // Uno de los nodos es NULL entonces no existe camino de A a B
//printf("Un nodo es invalido\n");
printf("0\n");
}
break;
case 'S':
//printf("S %i %i\n",A+1,B+1);
add_relation(A,B);
break;
}
i++;
}
fclose(in);
return 0;
}

void add_relation(int A,int B) {
if(todos[A] != NULL) {
//Nodo ya inicializado;
todos[A]->relations = realloc(todos[A]->relations,sizeof(int)*(todos[A]->total+1));
todos[A]->relations[todos[A]->total] = B;
todos[A]->arbol = agregar_valor_arbol(todos[A]->arbol,B);
todos[A]->total++; //incrementamos el numero total de relaciones que tiene este nodo
}
else {
//Nodo no inicializado
todos[A] = calloc(sizeof(struct nodo),1);
todos[A]->id  = A; //Esto es mera formalidad, ya que actualmente el indice del arreglo ya es el mismo "id"
todos[A]->relations = realloc(todos[A]->relations,sizeof(int)*(todos[A]->total+1));
todos[A]->relations[todos[A]->total] = B;
todos[A]->arbol = agregar_valor_arbol(todos[A]->arbol,B);
todos[A]->total++; //incrementamos el numero total de relaciones que tiene este nodo
todos[A]->visitado = 0;
todos[A]->offset = 0;
}
if(todos[B] != NULL) {
//Nodo ya inicializado;
todos[B]->relations = realloc(todos[B]->relations,sizeof(int)*(todos[B]->total+1));
todos[B]->relations[todos[B]->total] = A;
todos[B]->arbol = agregar_valor_arbol(todos[B]->arbol,A);
todos[B]->total++; //incrementamos el numero total de relaciones que tiene este nodo

}
else {
//Nodo no inicializado
todos[B] = calloc(sizeof(struct nodo),1);
todos[B]->id  = B; //Esto es mera formalidad, ya que actualmente el indice del arreglo ya es el mismo "id"
todos[B]->relations = realloc(todos[B]->relations,sizeof(int)*(todos[B]->total+1));
todos[B]->relations[todos[B]->total] = A;
todos[B]->arbol = agregar_valor_arbol(todos[B]->arbol,A);
todos[B]->total++; //incrementamos el numero total de relaciones que tiene este nodo
todos[B]->visitado = 0;
todos[B]->offset = 0;
}
}

//A.k.a diskjtra simplificado a aristas de valor 1 y solo valida que exista la union
bool existe_salto(int A,int B) {
bool r = false,outs = false;
struct nodo *nodo_a = NULL,*nodo_b =NULL,*inicio =NULL,*pivote = NULL;
struct nodo_arbol *busqueda = NULL;
struct nodo **pendientes = NULL;
register int i,j,buscar,total = 0;
int visitado;
visitado = rand();
nodo_a = todos[A];
nodo_b = todos[B];
if(nodo_a->total < nodo_b->total) {
inicio = nodo_a;
buscar = B;
//printf("Menor A %i\n",inicio->id+1);
}
else {
inicio = nodo_b;
buscar = A;
//printf("Menor B %i\n",inicio->id+1);
}
//printf("Nodos: ");
i = 0;
pendientes = realloc(pendientes,sizeof(struct nodo*)*(total+1));
pendientes[total] = inicio;
total++;
while(!r && i < total) {
pivote = pendientes[i];
pivote->visitado = visitado;
//printf("Visitando %i\n",pivote->id+1);
busqueda = buscar_nodo_arbol(pivote->arbol,buscar);
if(!busqueda) {
//printf("El nodo %i no tiene el nodo buscado %i\n",pivote->id+1,buscar+1);
j = 0;
while(j < pivote->total ) {
if(todos[pivote->relations[j]]->visitado != visitado) {
//printf("Anexando el nodo %i para su posterior visita\n",todos[pivote->relations[j]]->id+1);
pendientes = realloc(pendientes,sizeof(struct nodo*)*(total+1));
pendientes[total] = todos[pivote->relations[j]];
total++;
}
j++;
}
}
else {
//printf("El nodo %i SI tiene el nodo buscado %i\n",pivote->id+1,buscar+1);
r = true;
}
i++;
}
free(pendientes);
return r;
}

//Funciones de Arbol (Solo como almacenamiento y busqueda rapida)

struct nodo_arbol *crear_nodo_arbol(struct nodo_arbol *padre,int valor) {
struct nodo_arbol *n = calloc(sizeof(struct nodo_arbol),1);
if(n == NULL) {
printf("Error de Memoria\n");
exit(0);
}
n->padre = padre;
n->valor = valor;
return n;
}

struct nodo_arbol *agregar_valor_arbol(struct nodo_arbol *arbol,int valor) {
struct nodo_arbol *temp,*pivote;
int derecho = 0;
if(arbol) {
temp =arbol;
while(temp != NULL) {
pivote = temp;
if(valor > temp->valor) {
temp = temp->derecho;
derecho = 1;
}
else {
temp = temp->izquierdo;
derecho = 0;
}
}
temp = crear_nodo_arbol(pivote,valor);
if(derecho) {
pivote->derecho = temp;
}
else {
pivote->izquierdo = temp;
}
return arbol;
}
else {
temp = crear_nodo_arbol(NULL,valor);
return temp;
}
}

struct nodo_arbol *buscar_nodo_arbol(struct nodo_arbol *arbol,int valorAbuscar) {
struct nodo_arbol *temp = NULL,*pivote = NULL;
int entrar = 1;
temp =arbol;
while(entrar == 1  && temp != NULL) {
pivote = temp;
if(valorAbuscar == temp->valor){
entrar = 0;
}
else {
if(valorAbuscar > temp->valor) {
temp = temp->derecho;
}
else {
temp = temp->izquierdo;
}
}
}
return temp;
}

Código (c) [Seleccionar] Expandir

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stdbool.h>
#include<time.h>

#define MAXLINE 40

struct nodo_arbol {
struct nodo_arbol *padre,*derecho,*izquierdo;
struct nodo *valor;
};

struct arbol {
struct nodo_arbol *raiz;
struct nodo_arbol **nodos;
int total;
};

struct nodo {
int id;
struct arbol *arbol;
};

struct nodo **todos = NULL;

void add_relation(int A,int B);
bool existe_salto(int A,int B);
struct arbol *funciona_arbol(struct arbol *A,struct arbol *B);

struct nodo_arbol *crear_nodo_arbol(struct nodo_arbol *padre,struct nodo *valor);
struct arbol *agregar_valor_arbol(struct arbol *arbol,struct nodo *valor);

int main() {
FILE *in = NULL;
char *line = NULL;
char *delim = " \n";
char *token;
char caso;
int N,M,i,A,B;
in = fopen("amistad.in","r"); //Archivo ¬¬
srand(time(NULL)); // Para los nodos visitados...
line = calloc(MAXLINE,1);
//Leemos la primera linea
fgets(line,MAXLINE,in);
token = strtok(line,delim);
N = strtol(token,NULL,10);
todos = calloc(sizeof(struct nodo*),N); //Reservamos espacio para al menos N apuntadores a los nodos
token = strtok(NULL,delim);
M = strtol(token,NULL,10);
//Leemos las siguientes M lineas y evaluamos
i = 0;
while(i < M) {
memset(line,0,MAXLINE);
//Leemos la M,esima linea
fgets(line,MAXLINE,in);
token = strtok(line,delim);
caso = token[0];
token = strtok(NULL,delim);
A = strtol(token,NULL,10);
A--;
token = strtok(NULL,delim);
B = strtol(token,NULL,10);
B--;
//Evaluamos
switch(caso){
case 'P':
//printf("P %i %i\n",A+1,B+1);
if(todos[A] && todos[B]) { // Ambos nodos son Validos, entonces hay que buscar si existe al menos un camino de a A a B
if(existe_salto(A,B)) {
printf("1\n");
}
else {
printf("0\n");
}
}
else { // Uno de los nodos es NULL entonces no existe camino de A a B
//printf("Un nodo es invalido\n");
printf("0\n");
}
break;
case 'S':
//printf("S %i %i\n",A+1,B+1);
add_relation(A,B);
break;
}
i++;
}
fclose(in);
return 0;
}

void add_relation(int A,int B) {
struct nodo *nodo_a,*nodo_b;
if(todos[A] == NULL) { // Si no existe A lo inicializamos
todos[A] = calloc(sizeof(struct nodo),1);
todos[A]->id  = A;
}
if(todos[B] == NULL) { // Si no existe B lo inicializamos
todos[B] = calloc(sizeof(struct nodo),1);
todos[B]->id  = B;
}
nodo_a = todos[A];
nodo_b = todos[B];
if(!nodo_a->arbol && !nodo_b->arbol){ // Si ambos arboles son NULL los inicializamos
nodo_a->arbol = agregar_valor_arbol(nodo_a->arbol,nodo_a);
nodo_a->arbol = agregar_valor_arbol(nodo_a->arbol,nodo_b);
}
else {
if(nodo_a->arbol && !nodo_b->arbol) { //Si el arbol de A es valido y el de B no, agregamos B al arbol de A
nodo_a->arbol =agregar_valor_arbol(nodo_a->arbol,nodo_b);
}
else {
if(!nodo_a->arbol && nodo_b->arbol){ //Si el arbol de B es valid y el de A no, agregamo A al arbol de B
nodo_b->arbol =agregar_valor_arbol(nodo_b->arbol,nodo_a);
}
else{// En este punto ambos arboles son validos
if(nodo_a->arbol != nodo_b->arbol) { //Validamos si ambos arboles son distintos
if(nodo_a->arbol->total < nodo_b->arbol->total) { // Evaluamos cual es el arbol con mejor coste de fusion
nodo_b->arbol = funciona_arbol(nodo_b->arbol,nodo_a->arbol); //Fucionamos el arbol de A en el arbol de B
}
else {
nodo_a->arbol = funciona_arbol(nodo_a->arbol,nodo_b->arbol); //Fucionamos el arbol de B en el arbol de A
}
}
}
}
}
}

//Fucinamos el arbol B en el arbol A, y eliminamos B nodo por nodo y finalmente liberamos la estructura Arbol que usamos
struct arbol *funciona_arbol(struct arbol *A,struct arbol *B) {
int i = 0;
while(i<B->total) {
B->nodos[i];
A = agregar_valor_arbol(A,B->nodos[i]->valor);
free(B->nodos[i]);
i++;
}
free(B);
return A;
}


//Evaluar si existe un camino valido de A a B, se reduce a validar si estan en el mismo Arbol o no
bool existe_salto(int A,int B) {
struct nodo *nodo_a = NULL,*nodo_b =NULL;
nodo_a = todos[A];
nodo_b = todos[B];
return (nodo_a->arbol == nodo_b->arbol);
}


//Funcion auxiliar para crear un nodo de arbol
struct nodo_arbol *crear_nodo_arbol(struct nodo_arbol *padre,struct nodo *valor) {
struct nodo_arbol *n = calloc(sizeof(struct nodo_arbol),1);
if(n == NULL) {
printf("Error de Memoria\n");
exit(0);
}
n->padre = padre;
n->valor = valor;
return n;
}

//Agregamos un valor al arbol
struct arbol *agregar_valor_arbol(struct arbol *arbol,struct nodo *valor) {
struct nodo_arbol *temp,*pivote;
int derecho = 0;
if(arbol) {
temp =arbol->raiz;
while(temp != NULL) {
pivote = temp;
if(valor->id > temp->valor->id) {
temp = temp->derecho;
derecho = 1;
}
else {
temp = temp->izquierdo;
derecho = 0;
}
}
temp = crear_nodo_arbol(pivote,valor);
if(derecho) {
pivote->derecho = temp;
}
else {
pivote->izquierdo = temp;
}
valor->arbol = arbol;
arbol->nodos = realloc(arbol->nodos,sizeof(struct nodo*)*(arbol->total+1));
arbol->nodos[arbol->total] = temp;
}
else {
arbol = calloc(sizeof(struct arbol),1);
arbol->raiz = crear_nodo_arbol(NULL,valor);
arbol->nodos = realloc(arbol->nodos,sizeof(struct nodo_arbol*)*(arbol->total+1));
arbol->nodos[arbol->total] = arbol->raiz;
valor->arbol = arbol;
}
arbol->total++;
return arbol;
}