Arbol binario

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);
+
+	}
+
+
+}

ArbolBinario/src/Nodo.java

@@ -0,0 +1,19 @@
+
+
+public class Nodo implements Comparable<Nodo> {
+	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);
+	}
+
+}

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()));
+	}
+
+
+}

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");
+	}
+
+}

ArbolBinario/src/es/upm/dit/adsw/arbolbinario/ElementoDiccionario.java

@@ -0,0 +1,32 @@
+package es.upm.dit.adsw.arbolbinario;
+
+public class ElementoDiccionario implements Comparable<ElementoDiccionario>{
+
+	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);
+	}
+
+
+}

ArbolBinario/src/es/upm/dit/adsw/arbolbinario/Nodo.java

@@ -0,0 +1,45 @@
+package es.upm.dit.adsw.arbolbinario;
+
+public class Nodo implements Comparable<Nodo> {
+	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();
+	}
+
+}

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<Integer> inicial = new ArrayList<Integer>();
+		for (int i = 0; i < arr.length; i++) {
+			inicial.add(arr[i]);
+		}
+
+		List<Integer> resultado = sortInterno(inicial);
+
+		for (int i = 0; i < arr.length; i++) {
+			arr[i] = resultado.get(i);
+		}
+
+	}
+
+	private static List<Integer> sortInterno(List<Integer> inicial) {
+		// dividir 
+		// de una lista paso a tener 2
+		List<Integer> izquierda= new ArrayList<Integer>(), derecha = new ArrayList<Integer>();
+		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<Integer> resultado = new ArrayList<Integer>();
+		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;
+	}
+
+}