From f8219d2ba5155acec97b9805ffb75322a125a14e Mon Sep 17 00:00:00 2001 From: Javier Andion Date: Tue, 12 Mar 2024 11:52:49 +0100 Subject: [PATCH] Arbol binario --- ArbolBinario/src/ArbolBinario.java | 70 ++++++++ ArbolBinario/src/Nodo.java | 19 +++ .../src/es/upm/dit/adsw/arbolbinario/BST.java | 154 ++++++++++++++++++ .../es/upm/dit/adsw/arbolbinario/BSTTest.java | 14 ++ .../arbolbinario/ElementoDiccionario.java | 32 ++++ .../es/upm/dit/adsw/arbolbinario/Nodo.java | 45 +++++ Ordenacion/src/MergeSort.java | 56 +++++++ Ordenacion/src/PruebasOrdenacion.java | 3 +- Ordenacion/src/QuickSort.java | 4 + 9 files changed, 396 insertions(+), 1 deletion(-) create mode 100644 ArbolBinario/src/ArbolBinario.java create mode 100644 ArbolBinario/src/Nodo.java create mode 100644 ArbolBinario/src/es/upm/dit/adsw/arbolbinario/BST.java create mode 100644 ArbolBinario/src/es/upm/dit/adsw/arbolbinario/BSTTest.java create mode 100644 ArbolBinario/src/es/upm/dit/adsw/arbolbinario/ElementoDiccionario.java create mode 100644 ArbolBinario/src/es/upm/dit/adsw/arbolbinario/Nodo.java create mode 100644 Ordenacion/src/MergeSort.java create mode 100644 Ordenacion/src/QuickSort.java diff --git a/ArbolBinario/src/ArbolBinario.java b/ArbolBinario/src/ArbolBinario.java new file mode 100644 index 0000000..7a2a53b --- /dev/null +++ b/ArbolBinario/src/ArbolBinario.java @@ -0,0 +1,70 @@ +public class ArbolBinario { + private Nodo raiz; + private int alturaArbol; + + public ArbolBinario() { + } + + public void insertarNodoDesde(Nodo nodoPadre, Nodo nodoAInsertar) { + if (nodoAInsertar.valor < nodoPadre.valor) { + if (nodoPadre.hijoIzquierdo != null) { + insertarNodoDesde(nodoPadre.hijoIzquierdo, nodoAInsertar); + } else { + nodoPadre.hijoIzquierdo = nodoAInsertar; + return; + } + + } + else { + if (nodoPadre.hijoDerecho != null) { + insertarNodoDesde(nodoPadre.hijoDerecho, nodoAInsertar); + } else { + nodoPadre.hijoDerecho = nodoAInsertar; + return; + } + } + } + + public void insertarNodo(Nodo n) { + if (raiz == null) { + raiz = n; + return; + } + insertarNodoDesde(raiz, n); + } + + public boolean estaNodoRecursivo(Nodo nodoPadre, Nodo nodoABuscar) { + if (nodoABuscar.valor < nodoPadre.valor) { + if (nodoPadre.hijoIzquierdo != null) { + return estaNodoRecursivo(nodoPadre.hijoIzquierdo, nodoABuscar); + } else { + return false; + } + + } + else if (nodoABuscar.valor > nodoPadre.valor){ + if (nodoPadre.hijoDerecho != null) { + return estaNodoRecursivo(nodoPadre.hijoDerecho, nodoABuscar); + } else { + return false; + } + } + else { + return true; + } + } + + public boolean estaNodo(Nodo n) { + if (raiz == null) { + return false; + } + if (raiz.valor == n.valor) { + return true; + } + + return estaNodoRecursivo(raiz, n); + + } + + +} diff --git a/ArbolBinario/src/Nodo.java b/ArbolBinario/src/Nodo.java new file mode 100644 index 0000000..aa8327f --- /dev/null +++ b/ArbolBinario/src/Nodo.java @@ -0,0 +1,19 @@ + + +public class Nodo implements Comparable { + public int valor; + public Nodo hijoDerecho; + public Nodo hijoIzquierdo; + public int altura; + + public Nodo(int valor) { + this.valor = valor; + + } + + @Override + public int compareTo(Nodo o) { + return Integer.compare(valor, o.valor); + } + +} \ No newline at end of file diff --git a/ArbolBinario/src/es/upm/dit/adsw/arbolbinario/BST.java b/ArbolBinario/src/es/upm/dit/adsw/arbolbinario/BST.java new file mode 100644 index 0000000..6311142 --- /dev/null +++ b/ArbolBinario/src/es/upm/dit/adsw/arbolbinario/BST.java @@ -0,0 +1,154 @@ +package es.upm.dit.adsw.arbolbinario; + +public class BST { + + private Nodo raiz; + + public void insertar(ElementoDiccionario elemento) { + if(raiz == null) { + raiz = new Nodo(elemento); + } else { + insertar(raiz, elemento); + } + } + + private void insertar(Nodo nodoActual, ElementoDiccionario elemento) { + int comparacion = nodoActual.getElemento().compareTo(elemento); + if( comparacion == 0 ) { + nodoActual.getElemento().setValor(elemento.getValor()); + } else if (comparacion < 0) { + if(nodoActual.getHijoIzquierdo() != null) { + insertar(nodoActual.getHijoIzquierdo(), elemento); + } else { + nodoActual.setHijoIzquierdo(new Nodo(elemento)); + } + } else { + if(nodoActual.getHijoDerecho() != null) { + insertar(nodoActual.getHijoDerecho(), elemento); + } else { + nodoActual.setHijoDerecho(new Nodo(elemento)); + } + } + } + + public boolean buscar(int clave) { + if (raiz == null) { + return false; + } + return buscar(raiz,clave); + } + + private boolean buscar(Nodo nodoActual, int clave) { + int comparacion = Integer.compare(nodoActual.getClave(), clave); + if( comparacion == 0 ) { + return true; + } else if( comparacion < 0 ) { + if (nodoActual.getHijoIzquierdo() == null) { + return false; + } + return buscar(nodoActual.getHijoIzquierdo(), clave); + } else { + if (nodoActual.getHijoDerecho() == null) { + return false; + } + return buscar(nodoActual.getHijoDerecho(), clave); + } + } + + public ElementoDiccionario eliminar(int clave) { + if (raiz == null) { + return null; + } + if (Integer.compare(raiz.getClave(), clave) == 0) { + ElementoDiccionario resultado = raiz.getElemento(); + raiz = null; + return resultado; + } + return eliminar(raiz, clave); + } + + public ElementoDiccionario eliminar(Nodo nodoActual, int clave) { + int comparacion = Integer.compare(nodoActual.getClave(), clave); + + if (comparacion < 0) { + if (nodoActual.getHijoIzquierdo() == null) { + return null; + } + if (Integer.compare(nodoActual.getHijoIzquierdo().getClave(), clave) == 0) { + ElementoDiccionario resultado = nodoActual.getHijoIzquierdo().getElemento(); + eliminaNodo(nodoActual, true); + return resultado; + } else { + return eliminar(nodoActual.getHijoIzquierdo(), clave); + } + } else { + if (nodoActual.getHijoDerecho() == null) { + return null; + } + if (Integer.compare(nodoActual.getHijoDerecho().getClave(), clave) == 0) { + ElementoDiccionario resultado = nodoActual.getHijoDerecho().getElemento(); + eliminaNodo(nodoActual, false); + return resultado; + } else { + return eliminar(nodoActual.getHijoDerecho(), clave); + } + } + } + + private void eliminaNodo(Nodo padre, boolean izquierda) { + Nodo nodoAEliminar = izquierda ? padre.getHijoIzquierdo() : padre.getHijoDerecho(); + Nodo hijoIzquierdo = nodoAEliminar.getHijoIzquierdo(); + Nodo hijoDerecho = nodoAEliminar.getHijoDerecho(); + if (hijoIzquierdo == null && hijoDerecho == null) { + if (izquierda) { + padre.setHijoIzquierdo(null); + } else { + padre.setHijoDerecho(null); + } + } else if (hijoIzquierdo != null && hijoDerecho == null) { + if (izquierda) { + padre.setHijoIzquierdo(hijoIzquierdo); + } else { + padre.setHijoDerecho(hijoIzquierdo); + } + } else if (hijoIzquierdo == null && hijoDerecho != null) { + if (izquierda) { + padre.setHijoIzquierdo(hijoDerecho); + } else { + padre.setHijoDerecho(hijoDerecho); + } + } else { + Nodo nodoSustituto = hijoDerecho; + Nodo padreNodoSustituto = nodoAEliminar; + while(nodoSustituto.getHijoIzquierdo() != null) { + padreNodoSustituto = nodoSustituto; + nodoSustituto = nodoSustituto.getHijoIzquierdo(); + } + padreNodoSustituto.setHijoIzquierdo(nodoSustituto.getHijoDerecho()); + if (izquierda) { + nodoSustituto.setHijoIzquierdo(hijoIzquierdo); + nodoSustituto.setHijoDerecho(hijoDerecho); + padre.setHijoIzquierdo(nodoSustituto); + } else { + nodoSustituto.setHijoIzquierdo(hijoIzquierdo); + nodoSustituto.setHijoDerecho(hijoDerecho); + padre.setHijoDerecho(nodoSustituto); + } + } + } + + public int getAltura() { + if (raiz == null) { + return 0; + } + return 1 + getAltura(raiz); + } + + private int getAltura(Nodo nodoActual) { + if (nodoActual == null) + return 0; + return 1 + Math.max(getAltura(nodoActual.getHijoIzquierdo()), getAltura(nodoActual.getHijoIzquierdo())); + } + + +} diff --git a/ArbolBinario/src/es/upm/dit/adsw/arbolbinario/BSTTest.java b/ArbolBinario/src/es/upm/dit/adsw/arbolbinario/BSTTest.java new file mode 100644 index 0000000..aaf6f08 --- /dev/null +++ b/ArbolBinario/src/es/upm/dit/adsw/arbolbinario/BSTTest.java @@ -0,0 +1,14 @@ +package es.upm.dit.adsw.arbolbinario; + +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; + +class BSTTest { + + @Test + void test() { + fail("Not yet implemented"); + } + +} diff --git a/ArbolBinario/src/es/upm/dit/adsw/arbolbinario/ElementoDiccionario.java b/ArbolBinario/src/es/upm/dit/adsw/arbolbinario/ElementoDiccionario.java new file mode 100644 index 0000000..4efd43f --- /dev/null +++ b/ArbolBinario/src/es/upm/dit/adsw/arbolbinario/ElementoDiccionario.java @@ -0,0 +1,32 @@ +package es.upm.dit.adsw.arbolbinario; + +public class ElementoDiccionario implements Comparable{ + + private int clave; + private String valor; + public ElementoDiccionario(int clave, String valor) { + super(); + this.clave = clave; + this.valor = valor; + } + public String getValor() { + return valor; + } + public void setValor(String valor) { + this.valor = valor; + } + public int getClave() { + return clave; + } + @Override + public String toString() { + return "ElementoDiccionario [clave=" + clave + ", valor=" + valor + "]"; + } + + @Override + public int compareTo(ElementoDiccionario o) { + return Integer.compare(clave, o.clave); + } + + +} diff --git a/ArbolBinario/src/es/upm/dit/adsw/arbolbinario/Nodo.java b/ArbolBinario/src/es/upm/dit/adsw/arbolbinario/Nodo.java new file mode 100644 index 0000000..ba5aeaa --- /dev/null +++ b/ArbolBinario/src/es/upm/dit/adsw/arbolbinario/Nodo.java @@ -0,0 +1,45 @@ +package es.upm.dit.adsw.arbolbinario; + +public class Nodo implements Comparable { + private ElementoDiccionario elemento; + private Nodo hijoDerecho; + private Nodo hijoIzquierdo; + + public Nodo(ElementoDiccionario elemento) { + this.elemento = elemento; + } + + @Override + public int compareTo(Nodo o) { + return elemento.compareTo(o.elemento); + } + + public ElementoDiccionario getElemento() { + return elemento; + } + + public void setElemento(ElementoDiccionario elemento) { + this.elemento = elemento; + } + + public Nodo getHijoDerecho() { + return hijoDerecho; + } + + public void setHijoDerecho(Nodo hijoDerecho) { + this.hijoDerecho = hijoDerecho; + } + + public Nodo getHijoIzquierdo() { + return hijoIzquierdo; + } + + public void setHijoIzquierdo(Nodo hijoIzquierdo) { + this.hijoIzquierdo = hijoIzquierdo; + } + + public int getClave() { + return elemento.getClave(); + } + +} \ No newline at end of file diff --git a/Ordenacion/src/MergeSort.java b/Ordenacion/src/MergeSort.java new file mode 100644 index 0000000..12516f5 --- /dev/null +++ b/Ordenacion/src/MergeSort.java @@ -0,0 +1,56 @@ +import java.util.ArrayList; +import java.util.List; + +public class MergeSort { + + + public static void sort(int[] arr) { + + List inicial = new ArrayList(); + for (int i = 0; i < arr.length; i++) { + inicial.add(arr[i]); + } + + List resultado = sortInterno(inicial); + + for (int i = 0; i < arr.length; i++) { + arr[i] = resultado.get(i); + } + + } + + private static List sortInterno(List inicial) { + // dividir + // de una lista paso a tener 2 + List izquierda= new ArrayList(), derecha = new ArrayList(); + if (inicial.size()==1) { + //No puedo seguir dividiendo + derecha.addAll(inicial); + return derecha; + } else { + //Parto por la mitad + izquierda = inicial.subList(0, inicial.size()/2); + derecha = inicial.subList(inicial.size()/2, inicial.size()); + + } + + // ordenar cada mitad + izquierda = sortInterno(izquierda); + derecha = sortInterno(derecha); + + // juntar + List resultado = new ArrayList(); + while(!izquierda.isEmpty() && !derecha.isEmpty()) { + if(izquierda.get(0) < derecha.get(0)) { + resultado.add(izquierda.remove(0)); + } else { + resultado.add(derecha.remove(0)); + } + } + // añadimos el resto + resultado.addAll(izquierda); + resultado.addAll(derecha); + return resultado; + } + +} diff --git a/Ordenacion/src/PruebasOrdenacion.java b/Ordenacion/src/PruebasOrdenacion.java index 1e3cfab..555c151 100644 --- a/Ordenacion/src/PruebasOrdenacion.java +++ b/Ordenacion/src/PruebasOrdenacion.java @@ -6,7 +6,8 @@ public class PruebasOrdenacion { public static void main(String[] args) { int[] nums = GeneradorDatos.arrayEnteros(1000); imprimeArray(nums); - Burbuja.sort(nums); +// Burbuja.sort(nums); + MergeSort.sort(nums); imprimeArray(nums); System.out.println("Está el numero 100: "+ buscaNumero(nums, 100)); diff --git a/Ordenacion/src/QuickSort.java b/Ordenacion/src/QuickSort.java new file mode 100644 index 0000000..c32a706 --- /dev/null +++ b/Ordenacion/src/QuickSort.java @@ -0,0 +1,4 @@ + +public class QuickSort { + +}