diff --git a/Arbolbinario2.png b/Arbolbinario2.png new file mode 100644 index 0000000..d1b9cf5 Binary files /dev/null and b/Arbolbinario2.png differ diff --git a/Arbolbinariograph.png b/Arbolbinariograph.png new file mode 100644 index 0000000..3adb207 Binary files /dev/null and b/Arbolbinariograph.png differ diff --git a/Linkedvsnumpy.png b/Linkedvsnumpy.png new file mode 100644 index 0000000..3a74d63 Binary files /dev/null and b/Linkedvsnumpy.png differ diff --git a/Maxsub.py b/Maxsub.py new file mode 100644 index 0000000..ec523c7 --- /dev/null +++ b/Maxsub.py @@ -0,0 +1,9 @@ +def maxsub(arr): + maxend = maxsof = arr[0] + for i in arr[1:]: + maxend = max(i, maxend + i) + maxsof = max(maxsof, maxend) + return maxsof + +arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4] +print(f"Maximum subarray sum: {maxsub(arr)}") \ No newline at end of file diff --git a/arbolbinario.py b/arbolbinario.py new file mode 100644 index 0000000..a43f753 --- /dev/null +++ b/arbolbinario.py @@ -0,0 +1,133 @@ +import random +import plotly.express as px + +class TreeNode: + def __init__(self, value): + self.value = value + self.left = None + self.right = None + +class BinarySearchTree: + def __init__(self): + self.root = None + + def insert(self, value): + if not self.root: + self.root = TreeNode(value) + else: + self._insert_recursive(self.root, value) + + def _insert_recursive(self, current_node, value): + if value < current_node.value: + if current_node.left is None: + current_node.left = TreeNode(value) + else: + self._insert_recursive(current_node.left, value) + elif value > current_node.value: + if current_node.right is None: + current_node.right = TreeNode(value) + else: + self._insert_recursive(current_node.right, value) + else: + # Ignorar nodos duplicados + pass + + def search(self, value): + return self._search_recursive(self.root, value) + + def _search_recursive(self, current_node, value): + if current_node is None or current_node.value == value: + return current_node + if value < current_node.value: + return self._search_recursive(current_node.left, value) + return self._search_recursive(current_node.right, value) + + def delete(self, value): + self.root = self._delete_recursive(self.root, value) + + def _delete_recursive(self, current_node, value): + if current_node is None: + return current_node + + if value < current_node.value: + current_node.left = self._delete_recursive(current_node.left, value) + elif value > current_node.value: + current_node.right = self._delete_recursive(current_node.right, value) + else: + if current_node.left is None: + return current_node.right + elif current_node.right is None: + return current_node.left + + min_value = self._find_min_value(current_node.right) + current_node.value = min_value + current_node.right = self._delete_recursive(current_node.right, min_value) + + return current_node + + def _find_min_value(self, current_node): + min_value = current_node.value + while current_node.left is not None: + min_value = current_node.left.value + current_node = current_node.left + return min_value + + def inorder_traversal(self): + values = [] + self._inorder_traversal_recursive(self.root, values) + return values + + def _inorder_traversal_recursive(self, current_node, values): + if current_node is not None: + self._inorder_traversal_recursive(current_node.left, values) + values.append(current_node.value) + self._inorder_traversal_recursive(current_node.right, values) + + def plot_tree(self): + depths = [] + values = [] + self._plot_tree_recursive(self.root, 0, depths, values) + fig = px.line(x=depths, y=values, title='Binary Search Tree: Depth vs Value') + fig.update_layout(xaxis_title='Depth', yaxis_title='Value') + fig.show() + + def _plot_tree_recursive(self, current_node, depth, depths, values): + if current_node is not None: + self._plot_tree_recursive(current_node.left, depth + 1, depths, values) + depths.append(depth) + values.append(current_node.value) + self._plot_tree_recursive(current_node.right, depth + 1, depths, values) + +# Ejemplo de uso +if __name__ == "__main__": + bst = BinarySearchTree() + + # Insertar algunos valores aleatorios + for _ in range(10): + value = random.randint(1, 100) + bst.insert(value) + + # Verificar inserción correcta + print("Inorder traversal:") + print(bst.inorder_traversal()) + + # Buscar un valor en el árbol + search_value = 50 + found_node = bst.search(search_value) + if found_node: + print(f"El valor {search_value} está presente en el árbol") + else: + print(f"El valor {search_value} NO está presente en el árbol") + + # Eliminar un valor del árbol + delete_value = 50 + bst.delete(delete_value) + + # Verificar que se eliminó correctamente + found_node = bst.search(delete_value) + if not found_node: + print(f"El valor {delete_value} fue eliminado correctamente del árbol") + + # Visualizar el árbol + bst.plot_tree() + diff --git a/linkedlistvsnumpyarray.py b/linkedlistvsnumpyarray.py new file mode 100644 index 0000000..8bddfe2 --- /dev/null +++ b/linkedlistvsnumpyarray.py @@ -0,0 +1,75 @@ +import time +import numpy as np +import matplotlib.pyplot as plt + +# Clase Node para representar un nodo en la lista enlazada +class Node: + def __init__(self, data=None): + self.data = data + self.next = None + +# Clase LinkedList para representar una lista enlazada +class LinkedList: + def __init__(self): + self.head = None + + # Método para agregar un nodo al final de la lista enlazada + def append(self, data): + new_node = Node(data) + if not self.head: + self.head = new_node + else: + current = self.head + while current.next: + current = current.next + current.next = new_node + + # Método para convertir la lista enlazada a una lista de Python + def to_list(self): + list_ = [] + current = self.head + while current: + list_.append(current.data) + current = current.next + return list_ + +# Función para comparar el rendimiento entre lista enlazada y array NumPy +def compare_performance(sizes): + ll_times = [] + np_times = [] + + for size in sizes: + # Lista enlazada + ll = LinkedList() + start_time_ll = time.time() + for i in range(size): + ll.append(i) + end_time_ll = time.time() + ll_times.append(end_time_ll - start_time_ll) + + # NumPy array + start_time_np = time.time() + np_array = np.zeros(size) + for i in range(size): + np_array[i] = i + end_time_np = time.time() + np_times.append(end_time_np - start_time_np) + + return ll_times, np_times + +# Función principal para ejecutar y visualizar los resultados +def main(): + sizes = [10, 100, 1000, 10000] # Tamaños de datos para comparar + ll_times, np_times = compare_performance(sizes) + + # Graficando los resultados + plt.plot(sizes, ll_times, label="Linked List") + plt.plot(sizes, np_times, label="NumPy Array") + plt.xlabel('Tamaño de los datos') + plt.ylabel('Tiempo (segundos)') + plt.title('Comparación de Rendimiento: Lista Enlazada vs NumPy Array') + plt.legend() + plt.show() + +if __name__ == "__main__": + main() \ No newline at end of file