Linked List and Binary Search Tree_Ana Paula Ramirez.py

Arbol Binario de Busqueda.py

@@ -0,0 +1,85 @@
+import matplotlib.pyplot as plt
+
+# Se define la clase TreeNode para representar los nodos del árbol
+class TreeNode:
+    def __init__(self, key):
+        self.key = key  
+        self.left = None  # hijo izquierdo
+        self.right = None  # hijo derecho
+
+# Función para insertar un nodo en el árbol binario de búsqueda
+def insert_node(root, key):
+    if root is None:
+        return TreeNode(key)  
+
+    # Inserta el nodo en la posición adecuada
+    if key < root.key:
+        root.left = insert_node(root.left, key)  # Si el valor es menor, inserta en el subárbol izquierdo
+    elif key > root.key:
+        root.right = insert_node(root.right, key)  # Si el valor es mayor, inserta en el subárbol derecho
+
+    return root
+
+# Función recursiva para graficar el árbol binario
+def plot_tree(node, x, y, dx):
+    if node:
+        # Dibuja el nodo actual y su valor
+        plt.text(x, y, str(node.key), style='italic')
+
+        # Dibuja la conexión con el hijo izquierdo (si existe)
+        if node.left:
+            plt.plot([x, x - dx], [y - 1, y - 3], 'ko-') 
+            plot_tree(node.left, x - dx, y - 4, dx / 2)  
+
+        # Dibuja la conexión con el hijo derecho (si existe)
+        if node.right:
+            plt.plot([x, x + dx], [y - 1, y - 3], 'ko-')  
+            plot_tree(node.right, x + dx, y - 4, dx / 2) 
+
+# Función para dibujar el árbol binario
+def draw_binary_tree(root):
+    plt.figure(figsize=(8, 6))  
+    plt.axis('off')  
+    plot_tree(root, 0, 0, 30)  
+    plt.show()  
+
+# Función para encontrar el nodo mínimo en un subárbol
+def find_min_node(node):
+    current = node
+    while current.left:
+        current = current.left
+    return current
+
+# Función para eliminar un nodo en el árbol binario de búsqueda
+def delete_node(root, key):
+    if root is None:
+        return root
+
+    if key < root.key:
+        root.left = delete_node(root.left, key)  # Busca el nodo a eliminar en el subárbol izquierdo
+    elif key > root.key:
+        root.right = delete_node(root.right, key)  # Busca el nodo a eliminar en el subárbol derecho
+    else:  
+        if root.left is None:  
+            temp = root.right  
+            root = None  
+            return temp  
+        elif root.right is None:  
+            temp = root.left  
+            root = None  
+            return temp  
+
+        # Si el nodo a eliminar tiene ambos hijos
+        temp = find_min_node(root.right)  
+        root.key = temp.key  
+        root.right = delete_node(root.right, temp.key)  
+
+    return root  
+
+# Ejemplo 
+keys = [50, 30, 70, 20, 40, 60, 80]  
+root = None  
+for key in keys:
+    root = insert_node(root, key)  
+
+draw_binary_tree(root)  

Linked_List.py

@@ -0,0 +1,60 @@
+import time
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Se define la clase Node para representar un nodo en la lista enlazada
+class Node:
+    def __init__(self, data):
+        self.data = data  # Valor del nodo
+        self.next = None  # Siguiente nodo
+
+# Se define la clase LinkedList para la lista enlazada
+class LinkedList:
+    def __init__(self):
+        self.head = None  
+
+    # Método para insertar un nuevo nodo al principio de la lista
+    def insert_at_beginning(self, data):
+        new_node = Node(data)  
+        new_node.next = self.head  
+        self.head = new_node  
+
+# Función para medir el tiempo de inserción en una lista enlazada
+def linked_list_insertion_time(num_elements):
+    linked_list = LinkedList() 
+    start_time = time.time()  
+    for i in range(num_elements):
+        linked_list.insert_at_beginning(i)  
+    end_time = time.time()  
+    return end_time - start_time  
+
+# Función para medir el tiempo de inserción en un array NumPy
+def numpy_array_insertion_time(num_elements):
+    array = np.empty(0, dtype=int) 
+    start_time = time.time()  
+    for i in range(num_elements):
+        array = np.insert(array, 0, i) 
+    end_time = time.time()  
+    return end_time - start_time  
+
+num_elements_list = [100, 500, 1000, 5000, 10000]  # Lista de tamaños de elementos a probar
+linked_list_times = []  # Lista para almacenar los tiempos de inserción en la lista enlazada
+numpy_array_times = []  # Lista para almacenar los tiempos de inserción en el array NumPy
+
+# Itera sobre los diferentes tamaños de elementos y mide los tiempos de inserción
+for num_elements in num_elements_list:
+    linked_list_time = linked_list_insertion_time(num_elements)  
+    numpy_array_time = numpy_array_insertion_time(num_elements)  
+    linked_list_times.append(linked_list_time)  
+    numpy_array_times.append(numpy_array_time)  
+
+
+# Se grafican los tiempos de inserción en función del número de elementos para ambas estructuras de datos
+plt.plot(num_elements_list, linked_list_times, label="Lista enlazada") 
+plt.plot(num_elements_list, numpy_array_times, label="Array NumPy")  
+plt.xlabel("Número de elementos") 
+plt.ylabel("Tiempo de inserción (segundos)")  
+plt.title("Comparación del tiempo de inserción")  
+plt.legend() 
+plt.show()  
+