Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » Arboles

C/Visual C - Arboles

Volver
Nuevo Tema
<<>>
 
Vista:

Arboles

Publicado por claudio (37 intervenciones) el 09/03/2001 22:06:21
Hola!!!!
Quisiera saber si existe algún alma caritativa que me pueda facilitar los códigos en C/C++, o aunque sea los algorítmos para manejar árboles b.
No me refiero a los árboles binarios de busqueda, sino a esos que se les parten los nodos y que gráficamente serían así:

_________________
| | |
--------| 2 | 4 |-------
| |_______|________| |
| | |
v | |
__________ _______v_ _______v_______
| | | | | | |
|__1_____| |__3____| |__5___|___6___|

Disculpenme pero no se de que otro modo hacerme ententer ya que todos a los que les pregunté confunden este tipo de árbol con el arbol binario.
Espero que se entienda lo que pido.
Desde ya gracias :-)
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

Implementación de árboles B en C++

Publicado por Alejandro (913 intervenciones) el 09/09/2024 17:16:07
¡Hola, Claudio!

Entiendo que estás buscando información sobre los árboles B en C/C++. Los árboles B son una estructura de datos que se utilizan para organizar y almacenar datos de manera eficiente. A diferencia de los árboles binarios de búsqueda, los árboles B permiten tener más de dos hijos por nodo y están diseñados para manejar grandes cantidades de datos.

Aquí tienes un ejemplo de cómo podrías implementar un árbol B en C++:

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <iostream>
#include <vector>
 
// Definición de la clase NodoB
class NodoB {
public:
    bool hoja;
    std::vector<int> claves;
    std::vector<NodoB*> hijos;
 
    NodoB(bool hoja) {
        this->hoja = hoja;
    }
};
 
// Función para insertar una clave en un árbol B
void insertar(NodoB* raiz, int clave) {
    if (raiz->claves.size() == 2) {
        // Si el nodo está lleno, se divide en dos
        NodoB* nuevoNodo = new NodoB(raiz->hoja);
        nuevoNodo->claves.push_back(raiz->claves[2]);
 
        raiz->claves.pop_back();
 
        if (!raiz->hoja) {
            nuevoNodo->hijos.push_back(raiz->hijos[2]);
            nuevoNodo->hijos.push_back(raiz->hijos[3]);
 
            raiz->hijos.pop_back();
            raiz->hijos.pop_back();
        }
 
        // Inserta la clave en el nodo adecuado
        if (clave < raiz->claves[0]) {
            insertar(raiz->hijos[0], clave);
        } else if (clave < raiz->claves[1]) {
            insertar(raiz->hijos[1], clave);
        } else {
            insertar(raiz->hijos[2], clave);
        }
    } else {
        // Si el nodo no está lleno, inserta la clave en orden
        int i = raiz->claves.size() - 1;
        while (i >= 0 && clave < raiz->claves[i]) {
            raiz->claves[i + 1] = raiz->claves[i];
            i--;
        }
        raiz->claves[i + 1] = clave;
    }
}
 
// Función para imprimir un árbol B
void imprimir(NodoB* raiz) {
    for (int i = 0; i < raiz->claves.size(); i++) {
        std::cout << raiz->claves[i] << " ";
    }
    std::cout << std::endl;
 
    if (!raiz->hoja) {
        for (int i = 0; i < raiz->hijos.size(); i++) {
            imprimir(raiz->hijos[i]);
        }
    }
}
 
int main() {
    NodoB* raiz = new NodoB(true);
 
    insertar(raiz, 1);
    insertar(raiz, 2);
    insertar(raiz, 3);
    insertar(raiz, 4);
    insertar(raiz, 5);
    insertar(raiz, 6);
 
    imprimir(raiz);
 
    return 0;
}

En este ejemplo, creamos una clase `NodoB` que representa un nodo en el árbol B. Cada nodo tiene un vector de claves y un vector de punteros a los hijos. La función `insertar` se encarga de insertar una clave en el árbol B, dividiendo los nodos si es necesario. La función `imprimir` se utiliza para imprimir el contenido del árbol B.

Espero que este ejemplo te ayude a comprender cómo implementar y trabajar con árboles B en C++. ¡Buena suerte con tu proyecto!
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