/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 */
package com.mycompany.abb;

import java.util.ArrayList;

public class ABB {

    public static void main(String[] args) {
        System.out.println("Hello World!");
        Arbol a1 = new Arbol();
        a1.insertar(4);
        a1.insertar(4);
        a1.insertar(4);
        a1.insertar(4);
        a1.insertar(4);
        a1.insertar(4);
        a1.insertar(4);
        a1.insertar(6);
        a1.insertar(6);
        a1.insertar(6);
        a1.insertar(6);
        a1.insertar(8);
        a1.insertar(8);
        a1.insertar(8);
        a1.insertar(8);
        a1.inOrden();
        System.out.println("FRECUENCIA DESCENDENTE");
        a1.frecDesc();
        System.out.println("suma la frecuencias " + a1.sumaFrec());
        System.out.println("contarUnicos " + a1.contarUnico());
        System.out.println("contar frecuencia mayor a 1 = " + a1.frecMayorA(1));
        System.out.println("contar frecuencia " + a1.cantFrec());
        System.out.println("Frecuencia maxima " + a1.frecMax());

        ListaA Ar = new ListaA();

        Ar.insertarEnArbol(0, 20);
        Ar.insertarEnArbol(0, 30);
        Ar.insertarEnArbol(1, 40);
        Ar.insertarEnArbol(1, 60);
        Ar.insertarEnArbol(1, 70);
        Ar.insertarEnArbol(2, 80);
        Ar.insertarEnArbol(2, 90);
        Ar.insertarEnArbol(2, 100);
        Ar.insertarEnArbol(2, 110);

        System.out.println("Mostrar todos los arboles array :");
        Ar.mostrar();

        // Mostrar el árbol con mayor cantidad de elementos
        System.out.println("\narbol con mayor cantidad de elementos:");
        Ar.mayorCxA();

        // Mostrar el mayor elemento de cada árbol
        System.out.println("\nMayor elemento de cada arbol:");
        Ar.mayorxA();

        // Mostrar la suma de los elementos de cada árbol
        System.out.println("\nSuma de los elementos de cada arbol:");
        Ar.sumaxA();

        System.out.println("\nvaciarTodosLosArboles:");
        Ar.vaciarTodo();

        System.out.println("Mostrar todos los arboles array :");
        Ar.mostrar();
    }

    public static class Nodo {

        public Nodo izq;
        public Nodo der;
        public int elem;
        public int frec;

        public Nodo(int elem) {
            this.elem = elem;
            frec = 1;
            this.izq = this.der = null;
        }
    }

    public static class Arbol {

        public Nodo raiz;

        public Arbol() {
            raiz = null;
        }

        public boolean esVacio() {
            return raiz == null;
        }

        public void inOrden() {
            inOrden(raiz);
        }

        private void inOrden(Nodo p) {
            if (p != null) {
                inOrden(p.izq);
                //System.out.println(p.elem + "FRECUENCIA ---> " + p.frec);
                System.out.println(p.elem);
                inOrden(p.der);
            }
        }

        public int suma() {
            return suma(raiz);
        }

        private int suma(Nodo p) {
            if (p == null) {
                return 0;
            }
            return suma(p.izq) + suma(p.der) + p.elem;
        }

        public int mayor() {
            return mayor(raiz);
        }

        private int mayor(Nodo p) {
            if (p.der == null) {
                return p.elem;
            }
            return mayor(p.der);
        }

        public void insertar(int x) {
            raiz = insertar(raiz, x);
        }

        private Nodo insertar(Nodo p, int x) {
            if (p == null) {
                return new Nodo(x);
            }
            if (p.elem == x) {
                p.frec++;
                return p;
            }
            if (x < p.elem) {
                p.izq = insertar(p.izq, x);
            } else {
                p.der = insertar(p.der, x);
            }
            return p;
        }

        //1.- FRECUENCIA DESCENDENTE
        public void frecDesc() {
            frecDesc(raiz);
        }

        private void frecDesc(Nodo p) {
            if (p != null) {
                frecDesc(p.der);
                System.out.println(p.elem + "FRECUENCIA ---> " + p.frec);
                frecDesc(p.izq);
            }
        }

        //2.- SUMA DE FRECUENCIAS
        public int sumaFrec() {
            return sumaFrec(raiz);
        }

        private int sumaFrec(Nodo p) {
            if (p == null) {
                return 0;
            }
            return sumaFrec(p.izq) + sumaFrec(p.der) + p.frec;
        }

        //3 CONTAR ELEMENTOS DE UNA SOLA FRECUENCIA
        public int contarUnico() {
            return contarUnico(raiz);
        }

        private int contarUnico(Nodo p) {
            if (p == null) {
                return 0;
            }
            if (p.frec == 1) {
                return contarUnico(p.izq) + contarUnico(p.der) + 1;
            } else {
                return contarUnico(p.izq) + contarUnico(p.der);
            }
        }

        //4.-   CONTAR ELEMENTOS CON FRECUENCIAS MASYORES A:
        public int frecMayorA(int x) {
            return frecMayorA(x, raiz);
        }

        private int frecMayorA(int x, Nodo p) {
            if (p == null) {
                return 0;
            }
            int cont = 0;
            if (p.frec > x) {
                cont = 1;
            }
            cont += frecMayorA(x, p.izq);
            cont += frecMayorA(x, p.der);
            return cont;
        }

        //5.-   CANTIDAD DE FRECUENCIAS
        public int cantFrec() {
            return cantFrec(raiz);
        }

        private int cantFrec(Nodo p) {
            if (p == null) {
                return 0;
            }
            return cantFrec(p.izq) + cantFrec(p.der) + 1;
        }
        //6.-   FRECUENCIA MAXIMA

        public int frecMax() {
            return frecMax(raiz);
        }

        private int frecMax(Nodo p) {
            if (p == null) {
                return 0;
            }
            int maxIzq = frecMax(p.izq);
            int maxDer = frecMax(p.der);
            return Math.max(p.frec, Math.max(maxIzq, maxDer));
        }
    }

    public static class ListaA {

        private ArrayList<Arbol> elem;

        public ListaA() {
            this.elem = new ArrayList<>(10);
            for (int i = 0; i < 10; i++) {
                this.elem.add(new Arbol());
            }
        }

        public void insertarEnArbol(int indice, int valor) {
            this.elem.get(indice).insertar(valor);
            System.out.println(valor + " insertado en el arbol " + indice);
        }

        //1. MOSTRAR
        public void mostrar() {
            for (int i = 0; i < 10; i++) {
                if (!this.elem.get(i).esVacio()) {
                    System.out.println("Arbol " + i + ":");
                    this.elem.get(i).inOrden();
                } else {
                    System.out.println("Arbol " + i + " esta vacio.");
                }
            }
        }

        //2. ARBOL CON MAYOR CANTIDAD DE ELEMENTOS
        public void mayorCxA() {
            Arbol am = mayorC();
            am.inOrden();
        }

        private Arbol mayorC() {
            Arbol am = this.elem.get(0);
            for (int i = 0; i < 10; i++) {
                if (this.elem.get(i).cantFrec() > am.cantFrec()) {
                    am = this.elem.get(i);
                }
            }
            return am;
        }

        //3. Mayor Elemento de cada Arbol
        public void mayorxA() {
            for (int i = 0; i < 10; i++) {
                if (!this.elem.get(i).esVacio()) {
                    System.out.println("Arbol " + i + ": Mayor: "
                            + this.elem.get(i).mayor());
                }
            }
        }

        //4.  Muestra la suma de los elementos de cada ABB no vacío.
        public void sumaxA() {
            for (int i = 0; i < 10; i++) {
                if (!this.elem.get(i).esVacio()) {
                    System.out.println(this.elem.get(i).suma());
                }
            }
        }

        //5 Vacía todos los ABB en la lista.
        public void vaciarTodo() {
            for (int i = 0; i < 10; i++) {
                this.elem.set(i, new Arbol());
            }
            System.out.println("Todos los arboles han sido vaciados");
        }
    }
}