diff --git a/Arbol Binario.py b/Arbol Binario.py
new file mode 100644
index 0000000..0a929bc
--- /dev/null
+++ b/Arbol Binario.py	
@@ -0,0 +1,173 @@
+class Nodo:
+    def __init__(self, valor):
+        """
+        Inicializa un nuevo nodo en el árbol binario de búsqueda.
+
+        Args:
+        - valor: El valor que contendrá el nodo.
+        """
+        self.valor = valor
+        self.izquierda = None
+        self.derecha = None
+
+class ArbolBinarioBusqueda:
+    def __init__(self):
+        """
+        Inicializa un árbol binario de búsqueda vacío.
+        """
+        self.raiz = None
+
+    def insertar(self, valor):
+        """
+        Inserta un nuevo nodo con el valor dado en el árbol binario de búsqueda.
+
+        Args:
+        - valor: El valor que se desea insertar en el árbol.
+        """
+        if self.raiz is None:
+            self.raiz = Nodo(valor)
+        else:
+            self._insertar_recursivo(self.raiz, valor)
+
+    def _insertar_recursivo(self, nodo, valor):
+        """
+        Inserta recursivamente un nuevo nodo con el valor dado en el árbol.
+
+        Args:
+        - nodo: El nodo actual en el proceso de inserción.
+        - valor: El valor que se desea insertar en el árbol.
+        """
+        if valor < nodo.valor:
+            if nodo.izquierda is None:
+                nodo.izquierda = Nodo(valor)
+            else:
+                self._insertar_recursivo(nodo.izquierda, valor)
+        elif valor > nodo.valor:
+            if nodo.derecha is None:
+                nodo.derecha = Nodo(valor)
+            else:
+                self._insertar_recursivo(nodo.derecha, valor)
+        else:
+            # Valor ya existe, no se permite duplicados en un árbol binario de búsqueda
+            pass
+
+    def buscar(self, valor):
+        """
+        Busca si un valor dado está presente en el árbol binario de búsqueda.
+
+        Args:
+        - valor: El valor que se desea buscar en el árbol.
+
+        Returns:
+        - True si el valor está presente en el árbol, False en caso contrario.
+        """
+        return self._buscar_recursivo(self.raiz, valor)
+
+    def _buscar_recursivo(self, nodo, valor):
+        """
+        Busca recursivamente si un valor dado está presente en el árbol.
+
+        Args:
+        - nodo: El nodo actual en el proceso de búsqueda.
+        - valor: El valor que se desea buscar en el árbol.
+
+        Returns:
+        - True si el valor está presente en el árbol, False en caso contrario.
+        """
+        if nodo is None:
+            return False
+        if valor == nodo.valor:
+            return True
+        elif valor < nodo.valor:
+            return self._buscar_recursivo(nodo.izquierda, valor)
+        else:
+            return self._buscar_recursivo(nodo.derecha, valor)
+
+    def eliminar(self, valor):
+        """
+        Elimina un nodo con el valor dado del árbol binario de búsqueda.
+
+        Args:
+        - valor: El valor del nodo que se desea eliminar del árbol.
+        """
+        self.raiz = self._eliminar_recursivo(self.raiz, valor)
+
+    def _eliminar_recursivo(self, nodo, valor):
+        """
+        Elimina recursivamente un nodo con el valor dado del árbol.
+
+        Args:
+        - nodo: El nodo actual en el proceso de eliminación.
+        - valor: El valor del nodo que se desea eliminar del árbol.
+
+        Returns:
+        - El nodo modificado después de la eliminación.
+        """
+        if nodo is None:
+            return nodo
+
+        if valor < nodo.valor:
+            nodo.izquierda = self._eliminar_recursivo(nodo.izquierda, valor)
+        elif valor > nodo.valor:
+            nodo.derecha = self._eliminar_recursivo(nodo.derecha, valor)
+        else:
+            if nodo.izquierda is None:
+                return nodo.derecha
+            elif nodo.derecha is None:
+                return nodo.izquierda
+            else:
+                nodo.valor = self._encontrar_min_valor(nodo.derecha)
+                nodo.derecha = self._eliminar_recursivo(nodo.derecha, nodo.valor)
+        return nodo
+
+    def _encontrar_min_valor(self, nodo):
+        """
+        Encuentra recursivamente el valor mínimo en el subárbol derecho de un nodo.
+
+        Args:
+        - nodo: El nodo raíz del subárbol derecho.
+
+        Returns:
+        - El valor mínimo encontrado en el subárbol derecho.
+        """
+        min_valor = nodo.valor
+        while nodo.izquierda is not None:
+            min_valor = nodo.izquierda.valor
+            nodo = nodo.izquierda
+        return min_valor
+
+    def recorrido_inorden(self):
+        """
+        Realiza un recorrido inorden (izquierda, raíz, derecha) en el árbol.
+        """
+        return self._recorrido_inorden_recursivo(self.raiz)
+
+    def _recorrido_inorden_recursivo(self, nodo):
+        """
+        Realiza un recorrido inorden (izquierda, raíz, derecha) recursivo en el árbol.
+
+        Args:
+        - nodo: El nodo raíz del subárbol actual.
+        """
+        if nodo is not None:
+            self._recorrido_inorden_recursivo(nodo.izquierda)
+            print(nodo.valor, end=" ")
+            self._recorrido_inorden_recursivo(nodo.derecha)
+
+
+# Ejemplo de uso
+arbol = ArbolBinarioBusqueda()
+valores = [50, 30, 70, 20, 40, 60, 80]
+
+for valor in valores:
+    arbol.insertar(valor)
+
+print("Recorrido Inorden:")
+arbol.recorrido_inorden()
+
+print("\nBuscando el valor 40:", arbol.buscar(40))
+print("Buscando el valor 100:", arbol.buscar(100))
+
+arbol.eliminar(30)
+print("\nRecorrido Inorden después de eliminar el nodo con valor 30:")
+arbol.recorrido_inorden()
diff --git a/Lista_ligada.py b/Lista_ligada.py
new file mode 100644
index 0000000..2a9f91b
--- /dev/null
+++ b/Lista_ligada.py
@@ -0,0 +1,59 @@
+class Nodo:
+    def __init__(self, valor):
+        self.valor = valor
+        self.siguiente = None
+
+class ListaLigada:
+    def __init__(self):
+        self.cabeza = None
+
+    def insertar_al_final(self, valor):
+        if not self.cabeza:
+            self.cabeza = Nodo(valor)
+        else:
+            actual = self.cabeza
+            while actual.siguiente:
+                actual = actual.siguiente
+            actual.siguiente = Nodo(valor)
+
+    def imprimir(self):
+        actual = self.cabeza
+        while actual:
+            print(actual.valor, end=" ")
+            actual = actual.siguiente
+        print()
+
+    def __eq__(self, otra_lista):
+        actual_self = self.cabeza
+        actual_otra = otra_lista.cabeza
+        while actual_self and actual_otra:
+            if actual_self.valor != actual_otra.valor:
+                return False
+            actual_self = actual_self.siguiente
+            actual_otra = actual_otra.siguiente
+        # Las listas deben tener la misma longitud
+        return actual_self is None and actual_otra is None
+
+
+# Creamos dos listas ligadas
+lista_1 = ListaLigada()
+lista_1.insertar_al_final(1)
+lista_1.insertar_al_final(2)
+lista_1.insertar_al_final(3)
+
+lista_2 = ListaLigada()
+lista_2.insertar_al_final(1)
+lista_2.insertar_al_final(2)
+lista_2.insertar_al_final(3)
+
+# Imprimimos ambas listas
+print("Lista 1:")
+lista_1.imprimir()
+print("Lista 2:")
+lista_2.imprimir()
+
+# Comparamos las listas
+if lista_1 == lista_2:
+    print("Las listas son iguales")
+else:
+    print("Las listas son diferentes")
diff --git a/subconjuntos maximos.py b/subconjuntos maximos.py
new file mode 100644
index 0000000..ce8bebe
--- /dev/null
+++ b/subconjuntos maximos.py	
@@ -0,0 +1,23 @@
+def encontrar_subconjuntos_contiguos_maximos(conjunto):
+    subconjuntos_maximos = []
+    maximo_global = [0] * (len(conjunto) + 1)
+
+    for i in range(1, len(conjunto) + 1):
+        maximo_local = [0] * (len(conjunto) + 1)
+        for j in range(i, len(conjunto) + 1):
+            maximo_local[j] = max(maximo_local[j - 1] + conjunto[j - 1], conjunto[j - 1])
+            maximo_global[i] = max(maximo_global[i], maximo_local[j])
+    
+    maximo_global = max(maximo_global)
+    
+    for i in range(len(conjunto)):
+        for j in range(i + 1, len(conjunto) + 1):
+            if maximo_global == sum(conjunto[i:j]):
+                subconjuntos_maximos.append(conjunto[i:j])
+
+    return subconjuntos_maximos
+
+# Ejemplo de uso
+conjunto = [32,23,32,-32434,1,14,34,12,342,124,14,532,523,-643,32,4,43,-6375,23,5,-65334,324,234,234,5,-531246,1,146,1561,13,415,1,-516,514,51,34,-634]
+subconjuntos = encontrar_subconjuntos_contiguos_maximos(conjunto)
+print("Subconjuntos contiguos máximos:", subconjuntos)
\ No newline at end of file