En este tema, exploraremos los diferentes tipos de estructuras de datos que son fundamentales para la programación. Las estructuras de datos se pueden clasificar en varias categorías según su organización y las operaciones que permiten. A continuación, desglosaremos los tipos más comunes y sus características principales.

Las estructuras de datos lineales almacenan elementos en una secuencia lineal. Cada elemento tiene un único sucesor y un único predecesor, excepto el primer y el último elemento.

a. Arrays (Arreglos)

• Descripción: Una colección de elementos, todos del mismo tipo, almacenados en ubicaciones de memoria contiguas.
• Características:
  • Acceso rápido a elementos mediante índices.
  • Tamaño fijo.
  • Operaciones comunes: acceso, modificación, iteración.
• Ejemplo en Python:

  # Definición de un array en Python
  array = [1, 2, 3, 4, 5]
  print(array[2])  # Salida: 3
  

b. Listas Enlazadas

• Descripción: Una colección de nodos donde cada nodo contiene un dato y una referencia (enlace) al siguiente nodo en la secuencia.
• Características:
  • Tamaño dinámico.
  • Inserción y eliminación eficientes.
  • Acceso secuencial.
• Ejemplo en Python:

  class Node:
      def __init__(self, data):
          self.data = data
          self.next = None
  
  class LinkedList:
      def __init__(self):
          self.head = None
  
      def append(self, data):
          new_node = Node(data)
          if not self.head:
              self.head = new_node
              return
          last = self.head
          while last.next:
              last = last.next
          last.next = new_node
  
  # Uso de la lista enlazada
  ll = LinkedList()
  ll.append(1)
  ll.append(2)
  ll.append(3)
  

c. Pilas (Stacks)

• Descripción: Una colección de elementos con acceso restringido, siguiendo el principio LIFO (Last In, First Out).
• Características:
  • Operaciones principales: push (insertar), pop (eliminar), peek (consultar el elemento superior).
• Ejemplo en Python:

  stack = []
  stack.append(1)  # push
  stack.append(2)
  print(stack.pop())  # pop, salida: 2
  

d. Colas (Queues)

• Descripción: Una colección de elementos que sigue el principio FIFO (First In, First Out).
• Características:
  • Operaciones principales: enqueue (insertar), dequeue (eliminar).
• Ejemplo en Python:

  from collections import deque
  queue = deque()
  queue.append(1)  # enqueue
  queue.append(2)
  print(queue.popleft())  # dequeue, salida: 1
  

Las estructuras de datos no lineales no almacenan elementos en una secuencia lineal. Los elementos pueden tener múltiples relaciones.

a. Árboles

• Descripción: Una estructura jerárquica donde cada nodo tiene un valor y referencias a nodos hijos.
• Tipos Comunes:
  • Árbol Binario
  • Árbol Binario de Búsqueda (BST)
  • Árbol AVL
  • Árbol B
• Ejemplo de un Árbol Binario en Python:

  class TreeNode:
      def __init__(self, data):
          self.data = data
          self.left = None
          self.right = None
  
  # Creación de un árbol binario
  root = TreeNode(1)
  root.left = TreeNode(2)
  root.right = TreeNode(3)
  

b. Grafos

• Descripción: Una colección de nodos (vértices) y aristas (conexiones) entre ellos.
• Características:
  • Puede ser dirigido o no dirigido.
  • Puede tener ciclos.
• Ejemplo en Python:

  class Graph:
      def __init__(self):
          self.graph = {}
  
      def add_edge(self, node, neighbor):
          if node not in self.graph:
              self.graph[node] = []
          self.graph[node].append(neighbor)
  
  # Creación de un grafo
  g = Graph()
  g.add_edge(1, 2)
  g.add_edge(1, 3)
  g.add_edge(2, 4)
  

Estas estructuras definen operaciones sin especificar la implementación.

a. Conjuntos (Sets)

• Descripción: Una colección de elementos únicos.
• Características:
  • No permite duplicados.
  • Operaciones comunes: unión, intersección, diferencia.
• Ejemplo en Python:

  set1 = {1, 2, 3}
  set2 = {3, 4, 5}
  print(set1.union(set2))  # Salida: {1, 2, 3, 4, 5}
  

b. Diccionarios (Maps)

• Descripción: Una colección de pares clave-valor.
• Características:
  • Acceso rápido a valores mediante claves.
• Ejemplo en Python:

  dictionary = {'a': 1, 'b': 2, 'c': 3}
  print(dictionary['b'])  # Salida: 2
  

En esta sección, hemos cubierto los tipos más comunes de estructuras de datos, incluyendo estructuras lineales como arrays, listas enlazadas, pilas y colas, así como estructuras no lineales como árboles y grafos. También hemos visto estructuras abstractas como conjuntos y diccionarios. Cada tipo de estructura de datos tiene sus propias características y aplicaciones, y es fundamental comprenderlas para elegir la más adecuada según el problema que se desea resolver.

En el siguiente módulo, profundizaremos en las listas, comenzando con una introducción detallada y explorando sus diferentes variantes y aplicaciones.