Las 4 Estructuras de Datos que Te Harán Destacar en Entrevistas Senior
En la primera parte cubrimos las 5 estructuras fundamentales que aparecen en el 70% de las entrevistas. Ahora vamos un nivel más arriba.
Si estás aplicando a roles senior en empresas como MercadoLibre, Nubank, Cornershop, o buscando posiciones remotas en startups de Silicon Valley, estas cuatro estructuras son las que separan a los candidatos buenos de los excelentes.
1. Tree — La Base de la Jerarquía
Un árbol es una estructura jerárquica donde los datos se organizan en nodos conectados por relaciones padre-hijo. A diferencia de las estructuras lineales (arrays, listas), los árboles permiten representar relaciones naturalmente jerárquicas.
Anatomía de un árbol
- Raíz (root): El nodo superior, punto de entrada al árbol
- Padre/Hijo: Un nodo que conecta hacia abajo tiene hijos; hacia arriba, un padre
- Hoja (leaf): Nodo sin hijos
- Altura: Distancia máxima desde la raíz hasta cualquier hoja
Estructura de un nodo
class TreeNode {
int data;
TreeNode left;
TreeNode right;
TreeNode(int value) {
this.data = value;
this.left = null;
this.right = null;
}
}
Recorridos fundamentales
Los cuatro recorridos que debes dominar:
| Recorrido | Orden | Uso típico |
|---|---|---|
| Inorder | Izq → Raíz → Der | Obtener elementos ordenados (en BST) |
| Preorder | Raíz → Izq → Der | Copiar/serializar el árbol |
| Postorder | Izq → Der → Raíz | Eliminar el árbol, evaluar expresiones |
| Level Order | Nivel por nivel | BFS, encontrar profundidad mínima |
Cuándo usarlo
- Representar jerarquías (org charts, sistemas de archivos, DOM)
- Base para estructuras más específicas (BST, Heaps, Tries)
- Problemas de recursión y divide-and-conquer
Pregunta típica de entrevista
“Encuentra la altura máxima de un árbol binario.”
Estrategia: Recursión. La altura es 1 + max(altura_izquierda, altura_derecha). Caso base: nodo nulo retorna 0.
2. Binary Search Tree (BST) — Búsqueda Ordenada
Un BST es un árbol binario con una propiedad especial: para cada nodo, todos los valores a la izquierda son menores y todos los valores a la derecha son mayores.
Esta propiedad permite búsquedas en O(log n) — similar a búsqueda binaria, pero en estructura de árbol.
La propiedad BST
15
/ \
8 23
/ \ / \
4 11 17 27
Para el nodo 15: todo a la izquierda (8, 4, 11) es menor; todo a la derecha (23, 17, 27) es mayor.
Operaciones clave
// Búsqueda en BST
TreeNode search(TreeNode root, int target) {
if (root == null || root.data == target)
return root;
if (target < root.data)
return search(root.left, target);
else
return search(root.right, target);
}
Complejidad
| Operación | Promedio | Peor caso (desbalanceado) |
|---|---|---|
| Búsqueda | O(log n) | O(n) |
| Inserción | O(log n) | O(n) |
| Eliminación | O(log n) | O(n) |
| Inorder | O(n) | O(n) |
Importante: Un BST desbalanceado degenera en una lista enlazada. Por eso existen los árboles auto-balanceados (AVL, Red-Black).
Cuándo usarlo
- Necesitas datos ordenados con inserción/eliminación frecuente
- Implementar sets y maps ordenados
- Problemas que requieren encontrar sucesor/predecesor
Pregunta típica de entrevista
“Valida si un árbol binario es un BST válido.”
Estrategia: Recorrido inorder debe producir secuencia estrictamente creciente. O usar rangos: cada nodo debe estar entre un mínimo y máximo válido.
3. Heap — Priority Queues y Top-K
Un Heap es un árbol binario completo que mantiene la propiedad de heap: cada padre es mayor (max-heap) o menor (min-heap) que sus hijos.
La magia del heap: acceder al elemento máximo o mínimo en O(1), e insertar/eliminar en O(log n).
Min-Heap vs Max-Heap
- Min-Heap: El padre siempre es menor o igual que sus hijos. La raíz es el mínimo.
- Max-Heap: El padre siempre es mayor o igual que sus hijos. La raíz es el máximo.
Implementación con array
Los heaps se implementan eficientemente con arrays (sin punteros):
Para el índice i:
- Hijo izquierdo: 2*i + 1
- Hijo derecho: 2*i + 2
- Padre: (i - 1) / 2
// En Java, usa PriorityQueue
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
minHeap.offer(5); // insertar
int min = minHeap.peek(); // ver mínimo (O(1))
int removed = minHeap.poll(); // extraer mínimo (O(log n))
Complejidad
| Operación | Tiempo |
|---|---|
| Peek (ver raíz) | O(1) |
| Insert | O(log n) |
| Extract (remover raíz) | O(log n) |
| Heapify (construir heap) | O(n) |
Cuándo usarlo
- Implementar priority queues
- Problemas “Top K” o “K-ésimo más grande/pequeño”
- Algoritmos de grafos (Dijkstra, Prim)
- Merge de K listas ordenadas
Pregunta típica de entrevista
“Encuentra los K elementos más frecuentes en un array.”
Estrategia: HashMap para contar frecuencias + Min-Heap de tamaño K. O usa un Max-Heap y extrae K veces.
4. Graph — Modelando Relaciones Complejas
Un grafo representa relaciones entre entidades usando vértices (nodos) y aristas (conexiones). Es la estructura más flexible y poderosa para modelar el mundo real.
Tipos de grafos
| Tipo | Descripción | Ejemplo |
|---|---|---|
| Dirigido | Aristas tienen dirección (A→B) | Twitter follows, dependencias |
| No dirigido | Aristas bidireccionales (A—B) | Facebook amigos, rutas |
| Ponderado | Aristas tienen peso/costo | Mapas con distancias |
| DAG | Dirigido sin ciclos | Build systems, scheduling |
Representaciones
1. Matriz de adyacencia — O(1) para verificar aristas, O(V²) espacio
int[][] graph = new int[V][V];
graph[u][v] = 1; // arista de u a v
2. Lista de adyacencia — Eficiente en espacio O(V+E), ideal para grafos dispersos
Map<Integer, List<Integer>> graph = new HashMap<>();
void addEdge(int u, int v) {
graph.computeIfAbsent(u, k -> new ArrayList<>()).add(v);
graph.computeIfAbsent(v, k -> new ArrayList<>()).add(u); // si es no dirigido
}
Algoritmos esenciales
| Algoritmo | Propósito | Complejidad |
|---|---|---|
| BFS | Camino más corto (sin pesos), nivel por nivel | O(V + E) |
| DFS | Explorar todos los caminos, detectar ciclos | O(V + E) |
| Dijkstra | Camino más corto (con pesos positivos) | O((V+E) log V) |
| Topological Sort | Ordenar DAG por dependencias | O(V + E) |
Cuándo usarlo
- Redes sociales, sistemas de recomendación
- Rutas y navegación (Google Maps)
- Dependencias de tareas, builds, cursos
- Detección de ciclos, componentes conectados
Pregunta típica de entrevista
“Dado un grafo, determina si existe un camino entre dos nodos.”
Estrategia: BFS o DFS desde el nodo origen. Si llegas al destino, existe camino.
Comparativa Rápida
| Estructura | Fortaleza | Complejidad típica |
|---|---|---|
| Tree | Jerarquías, recursión | O(n) recorrido |
| BST | Búsqueda ordenada | O(log n) promedio |
| Heap | Acceso al min/max | O(1) peek, O(log n) insert |
| Graph | Relaciones complejas | O(V + E) traversal |
Próximamente: Parte 3
En la tercera y última parte cubriremos las estructuras especializadas que demuestran expertise avanzado:
- Trie — Autocompletado y búsqueda por prefijos
- Union-Find — Componentes conectados y detección de ciclos
- Matrix — Programación dinámica y grafos implícitos
¿Cuál de estas estructuras te ha dado más problemas en entrevistas? Comparte tu experiencia en los comentarios.
Este artículo es parte de la serie “Estructuras de Datos para Entrevistas Técnicas” en yoDEV. Síguenos para no perderte la próxima entrega.