Lista EnlazadaLINKED LIST

Es una colección de nodos donde cada nodo contiene un valor y una referencia (o enlace) al siguiente nodo en la secuencia. A diferencia de las listas en Python que son contiguas en memoria, las listas enlazadas permiten una inserción y eliminación más eficiente de elementos, ya que no requieren mover otros elementos.

Código en Python:

class Nodo:
    def __init__(self, valor):
        self.valor = valor
        self.siguiente = None

class ListaEnlazada:
    def __init__(self):
        self.cabeza = None

    def agregar(self, valor):
        nuevo_nodo = Nodo(valor)
        nuevo_nodo.siguiente = self.cabeza
        self.cabeza = nuevo_nodo

    def mostrar(self):
        actual = self.cabeza
        while actual:
            print(actual.valor)
            actual = actual.siguiente

# Uso de la lista enlazada
lista = ListaEnlazada()
lista.agregar(3)
lista.agregar(5)
lista.agregar(7)

lista.mostrar()  # Salida: 7, 5, 3

ÁrbolTree

Es una estructura de datos jerárquica que consiste en nodos conectados por aristas. Cada árbol tiene un nodo raíz, y cada nodo puede tener cero o más nodos hijos, formando una estructura ramificada.

Características de los Árboles:

• Nodos: Cada nodo contiene un valor y puede tener enlaces a otros nodos (hijos).
• Raíz: El nodo superior del árbol, que no tiene padre.
• Hojas: Nodos que no tienen hijos.
• Altura: La longitud del camino más largo desde la raíz hasta una hoja.
• Grado: El número de hijos que tiene un nodo.

Tipos Comunes de Árboles:

• Árbol Binario: Cada nodo tiene como máximo dos hijos (izquierdo y derecho).
• Árbol de Búsqueda Binaria: Un tipo de árbol binario donde los nodos a la izquierda de un nodo son menores y los nodos a la derecha son mayores.
• Árboles Balanceados: Como los árboles AVL o los árboles rojo-negro, que mantienen un equilibrio para garantizar un acceso eficiente.
• Árboles N-arios: Donde cada nodo puede tener hasta N hijos

Uso Común:

• Representación de jerarquías (por ejemplo, sistemas de archivos).
• Implementación de estructuras de datos complejas como tablas hash.
• Algoritmos de búsqueda y ordenación.

Código en Python:

class Nodo:
    def __init__(self, valor):
        self.valor = valor
        self.izquierdo = None
        self.derecho = None

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

    def agregar(self, valor):
        if self.raiz is None:
            self.raiz = Nodo(valor)
        else:
            self._agregar_recursivo(self.raiz, valor)

    def _agregar_recursivo(self, nodo, valor):
        if valor < nodo.valor:
            if nodo.izquierdo is None:
                nodo.izquierdo = Nodo(valor)
            else:
                self._agregar_recursivo(nodo.izquierdo, valor)
        else:
            if nodo.derecho is None:
                nodo.derecho = Nodo(valor)
            else:
                self._agregar_recursivo(nodo.derecho, valor)

# Uso del árbol binario
arbol = ArbolBinario()
arbol.agregar(10)
arbol.agregar(5)
arbol.agregar(15)

GrafosGraph

Es una estructura de datos que consiste en un conjunto de nodos (o vértices) conectados por aristas (o enlaces). Los grafos son utilizados para representar relaciones entre pares de elementos y son fundamentales en diversas aplicaciones.

Características de los Grafos

• Vértices: Los nodos del grafo, que pueden representar entidades o elementos.
• Aristas: Las conexiones entre los vértices, que pueden ser dirigidas (de un nodo a otro) o no dirigidas (sin dirección específica).
• Grado: El número de aristas incidentes en un vértice; en un grafo dirigido, se distingue entre grado de entrada y grado de salida.
• Altura: La longitud del camino más largo desde la raíz hasta una hoja.
• Grado: El número de hijos que tiene un nodo.

Tipos Grafos:

• Grafos Dirigidos: Las aristas tienen una dirección específica, de un vértice a otro.
• Grafos No Dirigidos: Las aristas no tienen dirección, y la conexión es bidireccional.
• Grafos Ponderados: Las aristas tienen un valor o peso asociado, que puede representar distancias, costos, etc.
• Grafos Conectados: Existe un camino entre cada par de vértices.
• Grafos Aislados: No hay aristas conectando los vértices.

Uso Común:

• Redes de computadoras.
• Sistemas de navegación y mapas.
• Representación de relaciones en bases de datos.
• Modelado de flujos en sistemas logísticos.

Código en Python:

class Grafo:
    def __init__(self):
        self.grafo = {}

    def agregar_vertice(self, vertice):
        if vertice not in self.grafo:
            self.grafo[vertice] = []

    def agregar_arista(self, vertice1, vertice2):
        self.grafo[vertice1].append(vertice2)
        self.grafo[vertice2].append(vertice1)  # Para un grafo no dirigido

# Uso del grafo
grafo = Grafo()
grafo.agregar_vertice('A')
grafo.agregar_vertice('B')
grafo.agregar_arista('A', 'B')

Bibliografía

• Goodrich, M. T., Tamassia, R., & Goldwasser, M. H. (2013).Data structures and algorithms in Python. John Wiley & Sons Ltd.