IsaiasLopezTzec

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)}")

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()
+

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()