¿Qué estructuras de datos existen?

Existen las siguientes estructuras de datos principales:

Primitivas:

• Números enteros (Integer)
• Números de punto flotante (Floating-point numbers)
• Valores booleanos (Boolean)
• Caracteres (Character)

Abstractas:

• Array: Colección ordenada de elementos del mismo tipo, acceso por índice con tiempo constante.
• Lista enlazada (Linked List): Colección de nodos, cada uno contiene datos y una referencia al siguiente nodo. Inserciones/eliminaciones eficientes al principio/final, acceso por índice - $O(n)$.
  • Lista enlazada simple (Singly Linked List)
  • Lista doblemente enlazada (Doubly Linked List)
  • Lista circular (Circular Linked List)
• Pila (Stack): Estructura LIFO (Last-In, First-Out). Operaciones: push (agregar), pop (eliminar), peek (ver el elemento superior).

  struct Stack<Element> {
      private var elements: [Element] = []
  
      mutating func push(_ element: Element) {
          elements.append(element)
      }
  
      mutating func pop() -> Element? {
          return elements.popLast()
      }
  
      func peek() -> Element? {
          return elements.last
      }
  
      var isEmpty: Bool {
          return elements.isEmpty
      }
  }
  

• Cola (Queue): Estructura FIFO (First-In, First-Out). Operaciones: enqueue (agregar), dequeue (eliminar), peek (ver el primer elemento).

  struct Queue<Element> {
      private var elements: [Element] = []
  
      mutating func enqueue(_ element: Element) {
          elements.append(element)
      }
  
      mutating func dequeue() -> Element? {
          guard !elements.isEmpty else { return nil }
          return elements.removeFirst()
      }
  
      func peek() -> Element? {
          return elements.first
      }
  
      var isEmpty: Bool {
          return elements.isEmpty
      }
  }
  

• Tabla hash (Hash Table) / Diccionario (Dictionary) / Array asociativo (Associative Array): Colección de pares "clave-valor", permite búsqueda, inserción y eliminación eficientes por clave usando función hash.

  var dictionary = [String: Any]() // Ejemplo de diccionario en Swift
  dictionary["key1"] = "value1"
  let value = dictionary["key1"]
  

• Conjunto (Set): Colección no ordenada de elementos únicos. Soporta operaciones: agregar, eliminar, verificar existencia, unión, intersección, diferencia.

  var set: Set<Int> = [1, 2, 3] // Ejemplo de conjunto en Swift
  set.insert(4)
  let containsTwo = set.contains(2)
  

• Árbol (Tree): Estructura jerárquica de datos, compuesta por nodos conectados por aristas. Tiene nodo raíz y nodos hijos.
  • Árbol binario (Binary Tree)
  • Árbol binario de búsqueda (Binary Search Tree - BST)
  • Árbol binario balanceado (Balanced Binary Tree) - AVL, árbol rojo-negro.
  • Árbol B (B-Tree)
• Grafo (Graph): Conjunto de vértices (nodos) y aristas (conexiones), que unen vértices. Puede ser dirigido o no dirigido, ponderado o no ponderado.

Comprender estas estructuras de datos es crucial para escribir código eficiente y escalable. La elección de la estructura adecuada depende de los requisitos de rendimiento (búsqueda, inserción, eliminación) y la naturaleza de los datos.