Algoritmia - altura de un arbol B+

 
Vista:

altura de un arbol B+

Publicado por rochi (1 intervención) el 29/08/2005 22:46:23
Hola estoy algo trancada con la función que me de la altura de un arbol B. Esto es, un árbol que puede tener entre 1 - cantHijos, cantHijos >= 1.
Lo estoy implementando en C, y esta es la estructura:

struct Afe
{
int valor;
int cantHijos;
struct Afe** hijos; // array de ptrs
};

AfeHijo(arbol,i), da el subárbol que está en la posición i.

Aqui está la función, pero no anda...hm es la altura en cuestión

void AfeHeight(Afe* arbol, int &hm, int &ha)
{
int i;

if (!AfeEsVacio(arbol))
{
ha++;

for(i = 0; (i < AfeCantHijos(arbol)); i++)
{
AfeHeight(AfeHijo(arbol,i),hm,ha);
if (ha > hm)
hm = ha;
ha = 0;
}
}
ha = 0;

}

gracias desde ya, saludos
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Cálculo de altura en un árbol B en C

Publicado por Alejandro (307 intervenciones) el 05/03/2024 19:59:56
Rochi, veamos algunos problemas en tu implementación y realicemos algunas correcciones:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include <stdio.h>
#include <stdlib.h>
 
struct Afe
{
    int valor;
    int cantHijos;
    struct Afe** hijos; // array de ptrs
};
 
// Suponiendo que tienes una función AfeEsVacio y AfeCantHijos ya definidas.
 
struct Afe* AfeHijo(struct Afe* arbol, int i)
{
    if (i < arbol->cantHijos)
        return arbol->hijos[i];
    else
        return NULL; // Manejar el caso de índice fuera de rango.
}
 
void AfeHeight(struct Afe* arbol, int* hm, int ha)
{
    if (arbol != NULL) // Verificar si el nodo actual no es nulo
    {
        ha++; // Incrementar la altura actual
 
        for (int i = 0; i < arbol->cantHijos; i++)
        {
            AfeHeight(AfeHijo(arbol, i), hm, ha);
        }
 
        if (ha > *hm)
            *hm = ha;
    }
}
 
int main()
{
    // Ejemplo de uso
    struct Afe* arbol = (struct Afe*)malloc(sizeof(struct Afe));
    arbol->valor = 1;
    arbol->cantHijos = 3;
 
    arbol->hijos = (struct Afe**)malloc(arbol->cantHijos * sizeof(struct Afe*));
    for (int i = 0; i < arbol->cantHijos; i++)
    {
        arbol->hijos[i] = (struct Afe*)malloc(sizeof(struct Afe));
        arbol->hijos[i]->valor = i + 2;
        arbol->hijos[i]->cantHijos = 0; // Asumiendo que inicialmente no hay hijos.
        arbol->hijos[i]->hijos = NULL;
    }
 
    int alturaMaxima = 0;
    int alturaActual = 0;
 
    AfeHeight(arbol, &alturaMaxima, alturaActual);
 
    printf("Altura del árbol: %d\n", alturaMaxima);
 
    // Liberar memoria utilizada
    // (Implementa tu propia función para liberar la memoria de manera recursiva)
    return 0;
}

Correcciones y comentarios:
1. Se ajustó la firma de la función `AfeHeight` para recibir un puntero a `hm` en lugar de una referencia. Los punteros son más comunes en C.
2. Se añadió la verificación de `arbol != NULL` al inicio de la función `AfeHeight` para evitar problemas con nodos nulos.
3. Se movió la reinicialización de `ha` fuera del bucle `for`, ya que deberías reiniciarla solo después de explorar todos los hijos del nodo actual.
4. Se añadió una función `AfeHijo` para obtener el hijo en una posición dada de manera más segura.

Ten en cuenta que el código proporcionado asume ciertos detalles en la implementación de otras funciones que no se han proporcionado en tu pregunta. Asegúrate de tener implementadas correctamente las funciones auxiliares (`AfeEsVacio`, `AfeCantHijos`, y las funciones para liberar memoria).
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar