fork download 
  1. #include <iostream>
  2. #include <queue>
  3. using namespace std;
  4.  
  5. struct Nodo {
  6.     int dato;
  7.     Nodo *izq;
  8.     Nodo *der;
  9.  
  10.     // Constructor
  11.     Nodo(int valor) : dato(valor), izq(nullptr), der(nullptr) {}
  12. };
  13.  
  14. class ArbolBinarioBusqueda {
  15. private:
  16.     Nodo *raiz;
  17.  
  18.     void insertarRec(Nodo *&r, int n) {
  19.         if (r == nullptr) {
  20.             r = new Nodo(n);
  21.         } else if (n < r->dato) {
  22.             insertarRec(r->izq, n);
  23.         } else if (n > r->dato) {
  24.             insertarRec(r->der, n);
  25.         }
  26.     }
  27.  
  28.     // Nuevo método privado para contar hojas
  29.     int contarHojasRec(Nodo *r) const {
  30.         // Caso 1: Árbol vacío o hijo inexistente
  31.         if (r == nullptr) {
  32.             return 0;
  33.         }
  34.  
  35.         // Caso 2: Es una hoja (no tiene hijos)
  36.         if (r->izq == nullptr && r->der == nullptr) {
  37.             return 1;
  38.         }
  39.  
  40.         // Caso 3: Nodo interno. Sumar las hojas de los subárboles.
  41.         return contarHojasRec(r->izq) + contarHojasRec(r->der);
  42.     }
  43.  
  44.     // Recorrido preorden
  45.     void preordenRec(Nodo *r) const {
  46.         if (r == nullptr) return;
  47.         cout << r->dato << ' ';
  48.         preordenRec(r->izq);
  49.         preordenRec(r->der);
  50.     }
  51.  
  52.     // Recorrido inorden
  53.     void inordenRec(Nodo *r) const {
  54.         if (r == nullptr) return;
  55.         inordenRec(r->izq);
  56.         cout << r->dato << ' ';
  57.         inordenRec(r->der);
  58.     }
  59.  
  60.     // Recorrido postorden
  61.     void postordenRec(Nodo *r) const {
  62.         if (r == nullptr) return;
  63.         postordenRec(r->izq);
  64.         postordenRec(r->der);
  65.         cout << r->dato << ' ';
  66.     }
  67.  
  68.     // Recorrido por nivel
  69.     void nivelRec(Nodo *r) const {
  70.         if (r == nullptr) return;
  71.         queue<Nodo*> cola;
  72.         cola.push(r);
  73.         while (!cola.empty()) {
  74.             Nodo *actual = cola.front();
  75.             cola.pop();
  76.             cout << actual->dato << ' ';
  77.             if (actual->izq != nullptr) cola.push(actual->izq);
  78.             if (actual->der != nullptr) cola.push(actual->der);
  79.         }
  80.     }
  81.  
  82.     // Liberar memoria
  83.     void liberar(Nodo *r) {
  84.         if (r == nullptr) return;
  85.         liberar(r->izq);
  86.         liberar(r->der);
  87.         delete r;
  88.     }
  89.  
  90. public:
  91.     // Constructor
  92.     ArbolBinarioBusqueda() : raiz(nullptr) {}
  93.  
  94.     // Destructor
  95.     ~ArbolBinarioBusqueda() {
  96.         liberar(raiz);
  97.     }
  98.  
  99.     // Métodos públicos
  100.     void insertar(int n) {
  101.         insertarRec(raiz, n);
  102.     }
  103.  
  104.     // Nuevo método público para contar hojas
  105.     int contarHojas() const {
  106.         return contarHojasRec(raiz);
  107.     }
  108.  
  109.     void mostrarPreorden() const {
  110.         cout << "Recorrido Preorden: ";
  111.         preordenRec(raiz);
  112.         cout << '\n';
  113.     }
  114.  
  115.     void mostrarInorden() const {
  116.         cout << "Recorrido Inorden: ";
  117.         inordenRec(raiz);
  118.         cout << '\n';
  119.     }
  120.  
  121.     void mostrarPostorden() const {
  122.         cout << "Recorrido Postorden: ";
  123.         postordenRec(raiz);
  124.         cout << '\n';
  125.     }
  126.  
  127.     void mostrarPorNivel() const {
  128.         cout << "Recorrido por Nivel: ";
  129.         nivelRec(raiz);
  130.         cout << '\n';
  131.     }
  132.  
  133.     bool estaVacio() const {
  134.         return raiz == nullptr;
  135.     }
  136. };
  137.  
  138. int main() {
  139.     ArbolBinarioBusqueda arbol;
  140.     int n;
  141.  
  142.     cout << "Ingrese números para el árbol (ingrese 0 o negativo para terminar):\n";
  143.     cin >> n;
  144.     while (n > 0) {
  145.         arbol.insertar(n);
  146.         cin >> n;
  147.     }
  148.  
  149.     if (!arbol.estaVacio()) {
  150.         arbol.mostrarPreorden();
  151.         arbol.mostrarInorden();
  152.         arbol.mostrarPostorden();
  153.         arbol.mostrarPorNivel();
  154.         cout << "Número de hojas en el árbol: " << arbol.contarHojas() << '\n';
  155.  
  156.     } else {
  157.         cout << "El árbol está vacío.\n";
  158.     }
  159.  
  160.     return 0;
  161. }
Success #stdin #stdout 0.01s 5288KB
comments (?)
stdin 
20 30 15 25 18 0
stdout 
Ingrese números para el árbol (ingrese 0 o negativo para terminar):
Recorrido Preorden: 20 15 18 30 25 
Recorrido Inorden: 15 18 20 25 30 
Recorrido Postorden: 18 15 25 30 20 
Recorrido por Nivel: 20 15 30 18 25 
Número de hojas en el árbol: 2
https://ideone.com/8G3ZcS
language:
C++ (gcc 8.3)
created:
15 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!