Última actualización: 2026-11-11

Contenido de esta página

• ¿Qué es una estructura de datos?
• Tipos de estructuras de datos: las cuatro clasificaciones
• Ejemplos de estructuras de datos: 8 estructuras con su costo y su uso
• Pilas y colas: LIFO y FIFO
• ¿Cómo elegir una estructura de datos?
• Las estructuras de datos, una por una
• La lista no estaba mal hecha

El 30 de noviembre de 2004 salió Python 2.4, una versión del lenguaje de programación Python [1]. Entre sus novedades venía un módulo nuevo, collections, pensado para tipos especializados de colecciones de datos [1]. Según la nota de cambios, por entonces traía un solo tipo: deque, una cola de doble extremo [1]. Su gracia era agregar y quitar elementos por cualquiera de sus dos puntas de manera eficiente [1].

La nota agregaba otro detalle. Varios módulos del propio lenguaje, como queue y threading, pasaban a usar deque para mejorar su rendimiento, un trabajo que acredita a Raymond Hettinger [1].

¿Por qué hacía falta, si Python ya tenía listas? Porque la lista sirve mal para una tarea concreta: atender en orden de llegada. El tutorial oficial lo explica hoy así: sacar el primer elemento de una lista es lento, porque todos los demás tienen que correrse un puesto [5]. Y recomienda la alternativa con estas palabras: «Para implementar una cola, utiliza collections.deque el cual fue diseñado para añadir y quitar de ambas puntas de forma rápida» [5].

Esa es la idea entera de esta guía. Los mismos datos se pueden guardar de varias maneras, y cada manera hace barata alguna operación y cara otra. Esas maneras se llaman estructuras de datos.

¿Qué es una estructura de datos?

Una estructura de datos es el orden que un programa le da a la información para que las operaciones que hace con ella salgan rápidas o gasten poca memoria. El NIST, el instituto de normas técnicas de Estados Unidos, mantiene un diccionario de algoritmos y estructuras de datos. Allí la describe como una organización de la información, por lo general en memoria, para mejorar la eficiencia de los algoritmos [2]. Un algoritmo es la lista de pasos que procesa esos datos; su definición completa está en la guía sobre qué es un algoritmo.

El mismo diccionario agrega un segundo uso. Una estructura también puede servir para darle unidad a datos que van juntos, como el nombre y la dirección de una persona [2]. Entre sus ejemplos clásicos están la cola, la pila, la lista enlazada, el montículo (un árbol en el que el valor de arriba es el menor o el mayor), el diccionario y el árbol [2].

¿Qué es un tipo abstracto de datos (TDA)?

Un tipo abstracto de datos, o TDA, es la descripción de un tipo de dato por lo que se puede hacer con él, sin decir cómo está construido por dentro. El NIST lo define como «un conjunto de valores de datos y operaciones asociadas que se especifican con precisión, independientes de cualquier implementación particular» [3]. La implementación es la parte que sí dice cómo: en qué orden quedan los datos en memoria y qué pasos sigue cada operación.

La cola sirve de ejemplo. Como TDA, una cola solo promete dos cosas: se agrega por el final y se saca por el frente, de modo que siempre sale el primero que llegó [4]. Esa promesa se puede cumplir de varias formas. Robert Sedgewick y Kevin Wayne, de la Universidad de Princeton, programan la misma cola dos veces en su libro Algorithms [10]. Una va sobre un arreglo que cambia de tamaño y otra sobre una lista enlazada [10].

Quien usa la cola no nota la diferencia en lo que hace. La nota en lo que tarda.

El NIST cuenta entre los tipos abstractos el diccionario, la pila, la cola, la cola de prioridad y el conjunto [3]. El diccionario, por ejemplo, guarda valores a los que se llega por una clave [4]. Puede construirse con una lista enlazada, una tabla hash (que ubica cada clave con una fórmula) o un árbol B (un árbol de varias ramas, usado en bases de datos), entre otras opciones [4][14]. Por eso conviene separar las dos preguntas. El TDA responde qué necesito hacer. La estructura de datos responde cómo lo hago rápido.

Tipos de estructuras de datos: las cuatro clasificaciones

Hay cuatro clasificaciones que la gente busca a menudo. Ninguna clasificación reemplaza a las otras: una misma estructura puede ser no primitiva, dinámica, lineal y homogénea a la vez. Esta tabla resume el criterio de cada una con un ejemplo, y las secciones que siguen la explican.

Clasificación	Pregunta que responde	Ejemplo de un lado	Ejemplo del otro
Primitivas y no primitivas	¿Viene definida por el lenguaje como valor básico o se arma combinando valores?	El entero int de Java [9]	El arreglo de Java, un objeto que contiene valores [9]
Estáticas y dinámicas	¿Su tamaño queda fijo al crearla o puede cambiar mientras el programa corre?	El arreglo de Java, de largo fijo [9]	El arreglo dinámico, cuyo tamaño puede cambiar [4]
Lineales y no lineales	¿Los elementos van uno detrás de otro o se ramifican?	Listas, pilas y colas [13]	Árboles y grafos [13]
Homogéneas y heterogéneas	¿Todos los elementos son del mismo tipo?	El arreglo del módulo array de Python [7]	La tupla de Python, que suele mezclar tipos [5]

Primitivas y no primitivas

Un tipo primitivo es un valor básico que el lenguaje trae definido de fábrica. El tutorial oficial de Java, escrito para la versión 8 del lenguaje, lo explica así: un tipo primitivo está predefinido por el lenguaje y se nombra con una palabra reservada [9]. Dos ejemplos son int y boolean. Java tiene ocho [9].

Lo no primitivo se construye a partir de esos valores. El mismo tutorial anota un caso curioso: el texto, la clase String, técnicamente no es un tipo primitivo, aunque el lenguaje lo trate con un soporte especial [9]. La distinción se hace sobre los tipos de datos de lenguajes como Java. Por eso casi todo lo que esta guía llama estructura, desde la lista hasta el grafo, cae del lado no primitivo.

Estáticas y dinámicas

Una estructura estática tiene un tamaño que se fija al crearla y ya no cambia; una dinámica puede crecer o encogerse mientras el programa corre. El tutorial de Java da el ejemplo estático: el largo de un arreglo se establece cuando se crea y después queda fijo [9]. El NIST da el dinámico: un arreglo dinámico es uno cuyo tamaño puede cambiar con el tiempo, y con él cambia también la memoria que usa [4].

La lista de Python es de este segundo tipo. Los apuntes del curso de algoritmos del MIT, el Instituto Tecnológico de Massachusetts, la presentan como un arreglo dinámico [12].

Una aclaración evita un error frecuente: «estructura de datos estática» no es lo mismo que «base de datos estática». La primera habla del tamaño de algo en la memoria de un programa. La segunda, de cada cuánto cambian los registros guardados, como explica la guía de bases de datos estáticas y dinámicas.

Lineales y no lineales

En una estructura lineal, cada elemento tiene a lo sumo uno antes y uno después, como una fila. En una no lineal, un elemento puede conectarse con varios. El NIST describe la lista en esa línea: una colección de elementos a los que se llega uno tras otro, desde la cabeza hasta la cola [4]. El árbol, en cambio, arranca en una raíz, y cada nodo interno puede tener uno o más hijos [4]. Y el grafo es un conjunto de elementos unidos por conexiones que se llaman aristas [4].

La clasificación tiene vocabulario propio en español. El programa de Algoritmos y Estructuras de Datos de la Universidad Nacional de Córdoba, en Argentina, la usa tal cual. Ubica listas y colas entre las lineales, y árboles y grafos entre las no lineales [13]. Su unidad de estructuras lineales incluye arreglos, listas simplemente enlazadas, pilas y colas [13].

Homogéneas y heterogéneas

Una estructura homogénea guarda elementos de un solo tipo; una heterogénea admite mezclarlos. El arreglo de Java guarda un número fijo de valores de un solo tipo [9]. En Python, el módulo array hace algo parecido: el tipo de sus elementos queda restringido desde que se crea el objeto [7].

Python matiza la idea con listas y tuplas. Su tutorial dice que los elementos de una lista son normalmente homogéneos y que las tuplas normalmente contienen una secuencia heterogénea [5]. La palabra que pesa ahí es «normalmente»: describe una costumbre de uso, no una prohibición del lenguaje. Los detalles de listas, tuplas, diccionarios y conjuntos como herramientas del lenguaje están en la guía de Python para análisis de datos.

Ejemplos de estructuras de datos: 8 estructuras con su costo y su uso

Esta tabla reúne ocho estructuras de datos con su operación típica, lo que esa operación cuesta y un uso real. El costo se escribe con la notación O grande, que dice cómo crece el tiempo cuando crece el número de datos, llamado n. Las tres marcas que más aparecen son estas:

• O(1): un tiempo que no crece con n.
• O(log n): un tiempo que crece muy despacio.
• O(n): un tiempo que crece en proporción a los datos.

Cada costo sale de una implementación concreta, y otra implementación puede dar números distintos. La documentación de Python lo advierte para sus propios tipos. Sus costos son los de CPython, la implementación canónica del lenguaje, la que se distribuye en python.org, y otras pueden rendir distinto [6].

Estructura	Operación típica	Costo	Lo que sale caro, o de qué depende	Caso de uso real
Arreglo (la list de Python)	Leer o cambiar un elemento por su posición	O(1) [6]	Insertar o sacar al inicio cuesta O(n), porque se corre todo lo demás [6]	Guardar valores que se leen por su número de puesto
Lista enlazada	Insertar o borrar al frente	Θ(1), tiempo constante [12]	Llegar a la posición i cuesta O(n) [12]	Base para construir pilas y colas [4][10]
Pila (list con append y pop)	Meter o sacar por arriba	O(1) amortizado: promedio sobre muchas operaciones [6]	A veces una operación sola cuesta O(n), cuando la lista crece y se muda en memoria [6]	El botón «atrás» del navegador [10]
Cola (collections.deque)	Agregar al final y sacar del frente	O(1), con un rendimiento «aproximadamente» igual en los dos extremos [7]	Con una lista en vez de una deque, sacar del frente cuesta O(n) [7]	Tareas que esperan turno en un computador [10]
Tabla hash (dict, set)	Buscar, insertar o borrar por clave	O(1) en promedio [6]	En el peor caso, O(n); depende de la función hash y del manejo de las colisiones [3][6]	Saber si un valor ya está y quitar repetidos [8]
Árbol de búsqueda balanceado	Buscar, insertar o borrar una clave	O(log n) en el peor caso, en los árboles rojo-negro y AVL (dos tipos de árbol que se mantienen equilibrados) del libro de Sedgewick y Wayne [11]	Un árbol de búsqueda sin balancear puede llegar a O(n) [11]	Las tablas y los índices del gestor de bases de datos SQLite, guardados en árboles B, otra familia de árboles balanceados [4][14]
Grafo	Recorrerlo completo por niveles o por ramas	O(V + E): vértices más conexiones [11]	Es el costo de la implementación del libro [11]; el NIST registra dos formas de representarlo, con listas o con una matriz [4]	Rutas entre ciudades, como en un mapa de carreteras [4]
Montículo (heapq)	Sacar el menor o insertar uno nuevo	O(log n) en un montículo binario, en el peor caso [11]	Otras variantes de montículo tienen costos distintos [11]	Ordenar tareas según su prioridad [15]

Tres términos de la tabla necesitan una línea. Un arreglo es un conjunto de elementos a los que se llega por un número entero, el índice [4]. Una tabla hash ubica cada clave en una posición calculada con una fórmula, la función hash, y cuando dos claves caen en el mismo sitio se produce una colisión [4]. Y un montículo es un árbol en el que el valor de arriba siempre es el menor, o el mayor [4][15].

Saco una lectura de la tabla: ninguna de las ocho es barata para todo. Cada fila abarata una operación y deja otra cara, o pone una condición. Por eso la misma estructura puede ser la mejor elección en un programa y la peor en otro.

Pilas y colas: LIFO y FIFO

Una pila y una cola guardan elementos en fila, y se diferencian solo en cuál sale primero. En la pila sale el último que entró: es la regla LIFO, sigla en inglés de «último en entrar, primero en salir» [4]. En la cola sale el primero que llegó: es la regla FIFO, «primero en entrar, primero en salir» [4].

Sedgewick y Wayne dan un ejemplo de cada una [10]. Para la pila, el navegador: cada enlace que se abre queda encima, y el botón «atrás» devuelve a la página anterior. Para la cola, los carros que esperan en una caseta de peaje, o las tareas que aguardan turno en un computador.

Una analogía de casa, solo como imagen: la pila es el arrume de platos recién lavados, donde se toma el de encima. La cola es la fila del banco.

Pilas y colas en Python: list y collections.deque

Python no trae un tipo llamado «pila» ni uno llamado «cola». Su documentación indica qué usar. Para una pila basta una lista: append() pone un elemento arriba y pop() sin índice saca el de arriba [5]. Para una cola recomienda collections.deque, porque la lista es lenta cuando se saca por el frente [5]. Este código hace las dos cosas:

from collections import deque

# Pila (LIFO): el historial del botón «atrás» de un navegador
historial = []
historial.append("inicio")       # push: entra una página
historial.append("noticias")
historial.append("deportes")
print(historial.pop())           # pop: sale la última que entró -> deportes

# Cola (FIFO): los carros que esperan en un peaje
peaje = deque()
peaje.append("carro 1")          # entra por el final
peaje.append("carro 2")
peaje.append("carro 3")
print(peaje.popleft())           # sale el primero que llegó -> carro 1

Al correrlo imprime «deportes» y luego «carro 1». La pila devolvió lo último; la cola, lo primero.

Cuánto cuesta usar la estructura equivocada: una medición en mi máquina

Para ver la diferencia en números medí una sola tarea: vaciar una cola de turnos sacando siempre el primero. Una vez con una lista y pop(0), y otra con una deque y popleft(). Usé timeit, el módulo de Python para medir trozos pequeños de código [16]. Tomé el mínimo de cinco repeticiones: según su documentación, probablemente es el único número que interesa mirar [16].

# Atender una cola de turnos: sacar siempre el primero que llegó.
# Misma tarea con dos estructuras: una lista y una deque (cola doble).
import platform
import timeit

print("Python", platform.python_version(), "|", platform.system(), platform.release())

for n in (10_000, 100_000):
    # Cada prueba arma una cola nueva con n turnos y la vacía de principio a fin
    preparar_lista = f"turnos = list(range({n}))"
    preparar_deque = f"from collections import deque; turnos = deque(range({n}))"

    # Lista: pop(0) saca el primero y corre todos los demás un puesto
    t_lista = min(timeit.repeat("while turnos: turnos.pop(0)",
                                setup=preparar_lista, number=1, repeat=5))
    # Deque: popleft() saca el primero sin mover el resto
    t_deque = min(timeit.repeat("while turnos: turnos.popleft()",
                                setup=preparar_deque, number=1, repeat=5))

    print(f"{n:>7,} turnos | lista: {t_lista:.4f} s | deque: {t_deque:.4f} s")

Lo corrí tres veces en mi computador, con Python 3.13.13 en Windows 11. Estos fueron los rangos:

Turnos en la cola	Lista con pop(0)	deque con popleft()
10.000	entre 0,006 y 0,009 segundos	entre 0,0004 y 0,0007 segundos
100.000	entre 1,04 y 1,20 segundos	entre 0,0048 y 0,0064 segundos

Lo que importa es cómo crecen los tiempos. Al pasar de 10.000 a 100.000 turnos, la lista tardó más de cien veces más en mi máquina. La deque tardó alrededor de diez veces más, más o menos en la misma proporción que los datos. Es lo que anuncia la documentación: con la lista, cada salida por el frente cuesta O(n), y con la deque, O(1) [7]. Otro computador dará otros segundos.

¿Cómo elegir una estructura de datos?

Para elegir una estructura de datos sirve preguntar primero qué operación se va a repetir más, y después buscar la estructura que la hace barata. Estas cuatro preguntas cubren la mayoría de los casos de quien empieza:

Pregunta	Si la respuesta es sí	Por qué
¿Necesito sacar los datos en un orden fijo, el de llegada o el inverso?	Cola (deque) para el orden de llegada; pila (list) para el inverso	Las dos sacan por su extremo en tiempo constante o casi [6][7]
¿Busco por una clave o pregunto si un valor ya está?	Tabla hash: dict o set	Buscar cuesta O(1) en promedio; en una lista, O(n) [6]
¿Inserto o borro en el medio a menudo?	Lista enlazada o árbol balanceado, en vez de un arreglo	Insertar en un arreglo cuesta O(n); el NIST sugiere esas dos salidas si eso resulta lento [4]
¿Necesito siempre el menor o el mayor de todos?	Montículo (heapq)	Deja el menor siempre en la primera posición [15]

Si ninguna pregunta da «sí», la lista simple suele bastar, porque leer por posición y agregar al final le salen baratos [6].

Las estructuras de datos, una por una

Esta guía da el mapa y el criterio. Cada estructura tendrá su desarrollo propio: arreglos, listas enlazadas, pilas, colas, tablas hash, árboles y grafos. Ahí irán las operaciones completas, las variantes y el código de cada una.

El orden en que conviene estudiarlas, junto con los algoritmos que trabajan sobre ellas, está en la guía de estructuras de datos y algoritmos. Y cuando la pregunta ya no es cómo ordena los datos un programa sino cómo los guarda un sistema completo, el tema son las bases de datos.

La lista no estaba mal hecha

Vuelvo a 2004. La lista no desapareció cuando llegó deque. Hace muy bien lo suyo, y su tutorial sigue mostrando lo fácil que es usarla como pila [5]. El problema era usarla para un trabajo que no le correspondía.

A mi juicio, lo que más rinde de esta guía no son las cuatro clasificaciones sino la tabla de costos. Saber si una estructura es lineal o dinámica sirve para un examen. Saber cuál de sus operaciones es barata sirve para que un programa de un analista termine en milésimas y no en segundos, con el mismo computador.

Antes de escribir la primera línea, pregúntese por dónde van a salir sus datos.

Preguntas frecuentes

¿Una lista de Python es un arreglo o una lista enlazada? Es un arreglo. Las preguntas frecuentes de diseño de Python lo dicen sin rodeos: las listas de CPython son arreglos de largo variable, no listas enlazadas [17]. Los apuntes del MIT la ponen como ejemplo de arreglo dinámico [12]. Por eso leer cualquier posición es inmediato, pero insertar al comienzo obliga a correr el resto de elementos [6].

¿Qué diferencia hay entre una cola y una cola de prioridad? La cola atiende por orden de llegada. La cola de prioridad atiende primero al elemento de mayor prioridad, sin importar cuándo entró [3]. El NIST anota que se puede implementar de forma eficiente con un montículo [3], y el módulo heapq de Python ofrece justo ese algoritmo [15].

¿Un diccionario de Python es una estructura de datos o un tipo abstracto? Las dos cosas, según desde dónde se mire. Como idea, el diccionario es un tipo abstracto: guarda valores y deja llegar a cada uno por su clave [4]. Como programa, el dict de CPython está construido sobre tablas hash que cambian de tamaño [17]. Su documentación explica que, frente a los árboles B, así se busca más rápido en la mayoría de los casos y la implementación es más simple [17].

¿Qué diferencia hay entre una pila y una cola? La pila entrega primero el último elemento que entró (LIFO), y la cola entrega primero el primero que entró (FIFO) [3][4]. En Python, una lista sirve bien de pila [5], pero para una cola conviene collections.deque, porque sacar el primer elemento de una lista cuesta O(n) [7].

¿Las estructuras de datos cambian de un lenguaje de programación a otro? La idea no cambia; la implementación sí. Una pila es LIFO en cualquier lenguaje, porque así la define su tipo abstracto [3][4]. Lo que varía es cómo la construye cada lenguaje y cuánto cuesta cada operación. La documentación de Python advierte que otras versiones del intérprete pueden tener costos distintos de los que publica [6].

Referencias

Las citas en otro idioma son traducción propia.

1. Python Software Foundation. Python Release Python 2.4.0 (fecha de lanzamiento: 30 de noviembre de 2004) y A. M. Kuchling, What’s New in Python 2.4 — nuevo módulo collections para tipos especializados de colecciones; «Currently it contains just one type, deque, a double-ended queue that supports efficiently adding and removing elements from either end»; módulos como queue y threading aprovechan collections.deque para mejorar el rendimiento («Contributed by Raymond Hettinger»). Python.org: Python 2.4.0 · Python docs: What’s New in Python 2.4 — Consultada: 2026-11-11.
2. NIST, Dictionary of Algorithms and Data Structures (Paul E. Black, ed.). Entrada data structure (modificada el 15 de diciembre de 2004) — «An organization of information, usually in memory, for better algorithm efficiency, such as queue, stack, linked list, heap, dictionary, and tree, or conceptual unity, such as the name and address of a person». NIST DADS: data structure — Consultada: 2026-11-11.
3. NIST, Dictionary of Algorithms and Data Structures (Paul E. Black, ed.). Entradas abstract data type («A set of data values and associated operations that are precisely specified independent of any particular implementation»; especializaciones: dictionary, stack, queue, priority queue, set, bag), priority queue (tipo abstracto para hallar de forma eficiente el elemento de mayor prioridad; «It can be implemented efficiently with a heap») y hash table (la complejidad depende de la función hash y del esquema de resolución de colisiones, y puede ser constante si la tabla es lo bastante grande o crece). NIST DADS: abstract data type · NIST DADS: priority queue · NIST DADS: hash table — Consultada: 2026-11-11.
4. NIST, Dictionary of Algorithms and Data Structures (Paul E. Black, ed.). Entradas queue (solo se accede al elemento agregado más temprano; FIFO), stack (solo se puede sacar el agregado más reciente; LIFO), dictionary (valores a los que se accede por una clave; implementaciones: lista enlazada, tabla hash, árbol B, entre otras), dynamic array («An array whose size may change over time»; cambia también la memoria usada), list (elementos accesibles uno tras otro, de la cabeza a la cola), tree (se accede desde la raíz; un nodo interno tiene uno o más hijos), graph (elementos conectados por aristas; representaciones por lista o por matriz de adyacencia; nota: un grafo es como un mapa de carreteras), linked list (puede usarse para implementar colas y pilas), array (elementos accesibles por un entero, el índice; «Inserting into an array takes O(n) time. If that’s too slow, use a balanced tree, skip list, or a linked list»), hash table (las claves se ubican en posiciones mediante funciones hash; colisión) y heap (árbol completo en el que cada nodo tiene una clave más extrema que la de su padre, o igual) y B-tree (árbol de búsqueda balanceado; buena estructura si gran parte del árbol está en memoria lenta, como el disco). NIST DADS: queue · NIST DADS: stack · NIST DADS: dictionary · NIST DADS: dynamic array · NIST DADS: list · NIST DADS: tree · NIST DADS: graph · NIST DADS: linked list · NIST DADS: array · NIST DADS: heap · NIST DADS: B-tree — Consultada: 2026-11-11.
5. Python Software Foundation. 5. Estructuras de datos, tutorial de Python, documentación en español 3.15.2, y su original 5. Data Structures — usar listas como pilas con append() y pop() sin índice; las listas no son eficientes como colas porque insertar o sacar al inicio obliga a correr los demás elementos; «Para implementar una cola, utiliza collections.deque el cual fue diseñado para añadir y quitar de ambas puntas de forma rápida»; las tuplas «normalmente contienen una secuencia heterogénea de elementos» y los elementos de las listas «son normalmente homogéneos». Python docs en español: Estructuras de datos · Python docs: Data Structures — Consultada: 2026-11-11.
6. Python Software Foundation. Time complexity of operations on built-in types, documentación de Python 3.15.2 — costos en CPython («Other Python implementations may have different performance characteristics»): list (leer o cambiar por posición O(1); append O(1) amortizado, con operaciones individuales que pueden costar O(n) cuando se redimensiona; pop e insert en la posición k O(n − k), peor caso en el índice 0; x in l O(n)); dict y set (O(1) en promedio, suponiendo pocas colisiones; O(n) en el peor caso, cuando todas las claves dan el mismo hash). Glosario: CPython es «The canonical implementation of the Python programming language, as distributed on python.org». Python docs: Time complexity of operations on built-in types · Python docs: Glossary, CPython — Consultada: 2026-11-11.
7. Python Software Foundation. collections — Container datatypes (sección deque objects) y array — Efficient arrays of numeric values, documentación de Python 3.15.2 — las deques admiten agregar y sacar por cualquier lado «with approximately the same O(1) performance in either direction», mientras las listas incurren en costos O(n) de movimiento de memoria para pop(0) e insert(0, v); en el módulo array, el tipo de los objetos guardados está restringido y se especifica al crear el objeto. Python docs: collections.deque · Python docs: array — Consultada: 2026-11-11.
8. Python Software Foundation. Built-in Types, sección Set types, documentación de Python 3.15.2 — un set es una colección no ordenada de objetos distintos; «Common uses include membership testing, removing duplicates from a sequence», entre otros. Python docs: Built-in Types, set — Consultada: 2026-11-11.
9. Oracle. The Java Tutorials (escritos para JDK 8): Primitive Data Types y Arrays — «A primitive type is predefined by the language and is named by a reserved keyword»; ocho tipos primitivos; la clase String «is not technically a primitive data type»; un arreglo es «a container object that holds a fixed number of values of a single type»; su largo se establece al crearlo y después queda fijo. Oracle: Primitive Data Types · Oracle: Arrays — Consultada: 2026-11-11.
10. Robert Sedgewick y Kevin Wayne, Princeton University. Algorithms, 4th Edition, sección 1.3 Bags, Queues, and Stacks — cola FIFO («people waiting in line at a theater, to cars waiting in line at a toll booth, to tasks waiting to be serviced by an application on your computer»); pila LIFO (el navegador apila cada página y el botón atrás la saca); ResizingArrayQueue implementa la API de cola con un arreglo que cambia de tamaño y Queue.java, con una lista enlazada; Stack.java implementa la pila con una lista enlazada. Princeton: Algorithms, 1.3 Bags, Queues, and Stacks — Consultada: 2026-11-11.
11. Robert Sedgewick y Kevin Wayne, Princeton University. Algorithms and Data Structures Cheatsheet — órdenes de crecimiento «as implemented in this textbook»: montículo binario, insertar y sacar el mínimo en log n (peor caso), con otras variantes (d-ario, binomial, de Fibonacci) de costos distintos; árbol binario de búsqueda sin balancear, búsqueda n en el peor caso; árboles rojo-negro y AVL, log n en el peor caso; recorridos DFS y BFS de un grafo, E + V. Princeton: Algorithms and Data Structures Cheatsheet — Consultada: 2026-11-11.
12. MIT OpenCourseWare. Erik Demaine, Jason Ku y Justin Solomon, 6.006 Introduction to Algorithms, Lecture 2: Data Structures (primavera de 2020) — lista enlazada: insertar y borrar al frente en Θ(1), leer o cambiar la posición i en O(n); arreglo dinámico como la list de Python, con append y pop en O(1) amortizado. MIT OCW: 6.006 Lecture 2, Data Structures (PDF) — Consultada: 2026-11-11.
13. Universidad Nacional de Córdoba, Facultad de Ciencias Exactas, Físicas y Naturales. Algoritmos y Estructuras de Datos, programa de la asignatura 10-09802 (aprobado por resolución 985-HCD-2025, 1 de diciembre de 2025) — contenido «Estructuras de datos lineales y no lineales»; la asignatura «desarrolla los temas de estructuras de datos lineales (listas, listas y colas), no lineales (árboles, grafos y otras)»; unidad 3, estructuras lineales: arreglos y vectores, listas simplemente enlazadas, pilas y colas; árboles en la unidad 6 y grafos en la 8. UNC FCEFyN: programa de Algoritmos y Estructuras de Datos (PDF) — Consultada: 2026-11-11.
14. SQLite. Database File Format, sección 1.6 B-tree Pages — SQLite usa dos variantes de árbol B: «Table b-trees» y «Index b-trees». SQLite: Database File Format — Consultada: 2026-11-11.
15. Python Software Foundation. heapq — Heap queue algorithm, documentación de Python 3.15.2 — implementación del algoritmo de montículo, «also known as the priority queue algorithm»; en un montículo de mínimos, el elemento menor siempre es la raíz, heap[0]; ejemplos con prioridades de tareas. Python docs: heapq — Consultada: 2026-11-11.
16. Python Software Foundation. timeit — Measure execution time of small code snippets, documentación de Python 3.15.2 — «a simple way to time small bits of Python code»; sobre los resultados de repeat(): «the min() of the result is probably the only number you should be interested in». Python docs: timeit — Consultada: 2026-11-11.
17. Python Software Foundation. Design and History FAQ, documentación de Python 3.15.2 — «CPython’s lists are really variable-length arrays, not Lisp-style linked lists»; «CPython’s dictionaries are implemented as resizable hash tables. Compared to B-trees, this gives better performance for lookup (the most common operation by far) under most circumstances, and the implementation is simpler». Python docs: How are lists implemented in CPython? · Python docs: How are dictionaries implemented in CPython? — Consultada: 2026-11-11.

Cómo investigamos esta página

• Pregunta que responde: qué es una estructura de datos, cómo se clasifica y con qué criterio se elige una
• Fuentes: identificadas 43 → incluidas 34
• Criterios de inclusión: diccionario del NIST, documentación oficial y material universitario, leídos en texto completo
• Fecha de corte de los datos: 2026-11-11