Skip to content

Daniel Herrera #7

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
DanielHerrera2002 wants to merge 2 commits into
base: main
Choose a base branch
from
Open

Daniel Herrera #7

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
e2ec173
Daniel Herrera
DanielHerrera2002 Apr 8, 2024
ecfb20d
Ejercicios usando la tecnica divide y venceras
DanielHerrera2002 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
68 changes: 68 additions & 0 deletions Arbolbinario.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,68 @@
class NodoArbol:
def __init__(self, valor):
self.valor = valor
self.izquierda = None
self.derecha = None

class ArbolBusqueda:
def __init__(self):
self.raiz = None

def insertar_nodo(self, valor):
if self.raiz is None:
self.raiz = NodoArbol(valor)
else:
self._insertar_nodo_recursivo(self.raiz, valor)

def _insertar_nodo_recursivo(self, nodo, valor):
if valor < nodo.valor:
if nodo.izquierda is None:
nodo.izquierda = NodoArbol(valor)
else:
self._insertar_nodo_recursivo(nodo.izquierda, valor)
elif valor > nodo.valor:
if nodo.derecha is None:
nodo.derecha = NodoArbol(valor)
else:
self._insertar_nodo_recursivo(nodo.derecha, valor)

def buscar_valor(self, valor):
return self._buscar_valor_recursivo(self.raiz, valor)

def _buscar_valor_recursivo(self, nodo, valor):
if nodo is None or nodo.valor == valor:
return nodo is not None
if valor < nodo.valor:
return self._buscar_valor_recursivo(nodo.izquierda, valor)
else:
return self._buscar_valor_recursivo(nodo.derecha, valor)

def _imprimir_nodos_recursivo(self, nodo, espacio):
if nodo is not None:
espacio += 5
self._imprimir_nodos_recursivo(nodo.derecha, espacio)
print()
for _ in range(5, espacio):
print(end=" ")
print(nodo.valor)
self._imprimir_nodos_recursivo(nodo.izquierda, espacio)

def imprimir_arbol(self):
self._imprimir_nodos_recursivo(self.raiz, 0)

#Ejemplo
arbol_busqueda = ArbolBusqueda()
arbol_busqueda.insertar_nodo(1)
arbol_busqueda.insertar_nodo(2)
arbol_busqueda.insertar_nodo(33)
arbol_busqueda.insertar_nodo(4)
arbol_busqueda.insertar_nodo(55)
arbol_busqueda.insertar_nodo(7)
arbol_busqueda.insertar_nodo(66)
arbol_busqueda.insertar_nodo(13)
arbol_busqueda.insertar_nodo(77)
arbol_busqueda.insertar_nodo(9)

#Print del árbol
print("Árbol de búsqueda:")
arbol_busqueda.imprimir_arbol()
67 changes: 67 additions & 0 deletions Array_enlist.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,67 @@
import numpy as np
import time
import matplotlib.pyplot as plt

class ListaVector:
def __init__(self):
"""
Constructor de la clase ListaVector.
Inicializa una lista vacía utilizando un vector NumPy.
"""
self.vector = np.array([])

def agregar_elemento_vector(self, valor):
"""
Agrega un nuevo elemento al final del vector.

Parámetros:
- valor: El valor que se agregará al vector.
"""
inicio = time.time()
self.vector = np.append(self.vector, valor)
fin = time.time()
return fin - inicio

def eliminar_elemento_vector(self, valor):
"""
Elimina la primera ocurrencia del valor proporcionado en el vector.

Parámetros:
- valor: El valor del elemento que se desea eliminar.
"""
inicio = time.time()
try:
indice = np.where(self.vector == valor)[0][0]
self.vector = np.delete(self.vector, indice)
except IndexError:
print(f"El valor {valor} no está en el vector.")
fin = time.time()
return fin - inicio

def imprimir_vector(self):
"""
Imprime todos los elementos del vector.
"""
print(self.vector)


#ejemplo de uso:
lista_vector = ListaVector()
tiempos_agregar_vector = []
tiempos_eliminar_vector = []

for i in range(1000):
tiempo_agregar_vector = lista_vector.agregar_elemento_vector(i)
tiempos_agregar_vector.append(tiempo_agregar_vector)

for i in range(1000):
tiempo_eliminar_vector = lista_vector.eliminar_elemento_vector(i)
tiempos_eliminar_vector.append(tiempo_eliminar_vector)

print("Gráfico de tiempo de agregar y eliminar elementos en Lista Vector con NumPy:")
plt.plot(range(1000), tiempos_agregar_vector, label='Agregar')
plt.plot(range(1000), tiempos_eliminar_vector, label='Eliminar')
plt.xlabel('Número de elementos')
plt.ylabel('Tiempo (segundos)')
plt.legend()
plt.show()
4 changes: 4 additions & 0 deletions Comparacion de complejidades.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,4 @@
Comparación de Complejidades
El algoritmo iterativo divide repetidamente el rango de números por la mitad hasta que encuentra el número deseado. Por lo tanto, su complejidad de tiempo es O(logn).

El algoritmo recursivo también divide el rango de números por la mitad en cada llamada recursiva. Sin embargo, cada llamada recursiva crea una nueva instancia de la función con nuevos parámetros, lo que puede aumentar el tiempo de ejecución y el uso de la memoria. La complejidad de su tiempo también es O(logn), pero puede tener un mayor costo de memoria debido a las llamadas recursivas.
98 changes: 98 additions & 0 deletions Listaenlazada.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,98 @@
import time
import matplotlib.pyplot as plt

class NodoLista:
def __init__(self, valor):
"""
Constructor de la clase NodoLista.

Parámetros:
- valor: El valor que contendrá el nodo.
"""
self.valor = valor
self.siguiente = None #enlace al siguiente nodo


class ListaEnlazadaSimple:
def __init__(self):
"""
Constructor de la clase ListaEnlazadaSimple.
Inicializa una lista enlazada vacía.
"""
self.inicio = None #referencia al primer nodo de la lista

def agregar_elemento_lista(self, valor):
"""
Agrega un nuevo elemento al final de la lista enlazada.

Parámetros:
- valor: El valor que se agregará a la lista.
"""
inicio = time.time()
nuevo_nodo = NodoLista(valor) #nuevo nodo con el valor proporcionado
if self.inicio is None: #si la lista está vacía, el nuevo nodo se convierte en la cabeza
self.inicio = nuevo_nodo
else:
#recorre la lista hasta encontrar el último nodo
actual = self.inicio
while actual.siguiente:
actual = actual.siguiente
#agrega el nuevo nodo al final de la lista
actual.siguiente = nuevo_nodo
fin = time.time()
return fin - inicio

def eliminar_elemento_lista(self, valor):
"""
Elimina el primer nodo que contenga el valor proporcionado de la lista enlazada.

Parámetros:
- valor: El valor del nodo que se desea eliminar.
"""
inicio = time.time()
actual = self.inicio #inicia desde la cabeza de la lista
anterior = None #almacena el nodo anterior al actual
#busca el nodo con el valor especificado
while actual and actual.valor != valor:
anterior = actual
actual = actual.siguiente
if actual: #si se encontró un nodo con el valor especificado
if anterior is None: #si el nodo a eliminar es la cabeza
self.inicio = actual.siguiente #actualiza la cabeza de la lista
else:
#elimina el nodo actual actualizando el enlace del nodo anterior
anterior.siguiente = actual.siguiente
fin = time.time()
return fin - inicio

def imprimir_elementos_lista(self):
"""
Imprime los valores de todos los nodos en la lista enlazada.
"""
actual = self.inicio
while actual:
print(actual.valor, end=" -> ")
actual = actual.siguiente
print("None")


#ejemplo de uso:
lista_enlazada = ListaEnlazadaSimple()
tiempos_agregar_lista = []
tiempos_eliminar_lista = []

for i in range(1000):
tiempo_agregar_lista = lista_enlazada.agregar_elemento_lista(i)
tiempos_agregar_lista.append(tiempo_agregar_lista)

for i in range(1000):
tiempo_eliminar_lista = lista_enlazada.eliminar_elemento_lista(i)
tiempos_eliminar_lista.append(tiempo_eliminar_lista)

print("Gráfico de tiempo de agregar y eliminar elementos en lista enlazada:")
plt.plot(range(1000), tiempos_agregar_lista, label='Agregar')
plt.plot(range(1000), tiempos_eliminar_lista, label='Eliminar')
plt.xlabel('Número de elementos')
plt.ylabel('Tiempo (segundos)')
plt.legend()
plt.show()
20 changes: 20 additions & 0 deletions algoritmo iterativo.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,20 @@
def guess_number_iterative(n, x):
moves = 0
smallest = 1
largest = n

while True:
guess = (smallest + largest) // 2
if guess == x:
print(f"Se adivinó el número {x} en {moves} movimientos.")
return moves
elif guess < x:
smallest = guess + 1
else:
largest = guess - 1
moves += 1

#ejemplo de uso del algoritmo iterativo
n = 100
x = 42
print(f"numero de movimientos necesarios para adivinar {x} es: {guess_number_iterative(n, x)}")
17 changes: 17 additions & 0 deletions algoritmo recursivo.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,17 @@
def guess_number_recursive(n, x, smallest=1, largest=None, moves=0):
if largest is None:
largest = n

guess = (smallest + largest) // 2
if guess == x:
print(f"Se adivinó el número {x} en {moves} movimientos.")
return moves
elif guess < x:
return guess_number_recursive(n, x, guess + 1, largest, moves + 1)
else:
return guess_number_recursive(n, x, smallest, guess - 1, moves + 1)

#ejemplo de uso del algoritmo recursivo
n = 100
x = 42
print(f"numero de movimientos necesarios para adivinar {x} es: {guess_number_recursive(n, x)}")