diff --git a/Arbolbinario.py b/Arbolbinario.py new file mode 100644 index 0000000..a7c8d9f --- /dev/null +++ b/Arbolbinario.py @@ -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() \ No newline at end of file diff --git a/Array_enlist.py b/Array_enlist.py new file mode 100644 index 0000000..ae10ac3 --- /dev/null +++ b/Array_enlist.py @@ -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() diff --git a/Comparacion de complejidades.txt b/Comparacion de complejidades.txt new file mode 100644 index 0000000..d9a69c8 --- /dev/null +++ b/Comparacion de complejidades.txt @@ -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. \ No newline at end of file diff --git a/Listaenlazada.py b/Listaenlazada.py new file mode 100644 index 0000000..69cac48 --- /dev/null +++ b/Listaenlazada.py @@ -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() diff --git a/algoritmo iterativo.py b/algoritmo iterativo.py new file mode 100644 index 0000000..699abda --- /dev/null +++ b/algoritmo iterativo.py @@ -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)}") diff --git a/algoritmo recursivo.py b/algoritmo recursivo.py new file mode 100644 index 0000000..0e75628 --- /dev/null +++ b/algoritmo recursivo.py @@ -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)}")