Skip to content

List array #16

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
AlanVAal wants to merge 3 commits into
base: main
Choose a base branch
from
Open

List array #16

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
ecdf7bd
Add files via upload
AlanVAal Apr 10, 2024
e2d6bca
Add files via upload
AlanVAal Apr 10, 2024
8e2b795
Add files via upload
AlanVAal Apr 10, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
173 changes: 173 additions & 0 deletions Arbol Binario.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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()
59 changes: 59 additions & 0 deletions Lista_ligada.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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")
23 changes: 23 additions & 0 deletions subconjuntos maximos.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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)