Loading...
Community presentation
┌─────────────────────────────────────────────────────────────────┐ │ 📚 ¿QUÉ ES UNA LISTA ENLAZADA? │ │ │ │ DEFINICIÓN: │ │ Una lista enlazada es una estructura de datos dinámi…
Create your own version
Use this visual direction as inspiration for a new Presenton deck.
Use this designCreator prompt
┌─────────────────────────────────────────────────────────────────┐ │ 📚 ¿QUÉ ES UNA LISTA ENLAZADA? │ │ │ │ DEFINICIÓN: │ │ Una lista enlazada es una estructura de datos dinámica │ │ donde cada elemento (nodo) contiene: │ │ 1. DATOS (información del elemento) │ │ 2. PUNTERO (referencia al siguiente nodo) │ │ │ │ ESTRUCTURA DE UN NODO: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ ┌──────────────┐ ┌──────────────┐ │ │ │ │ │ DATOS │ │ DATOS │ │ │ │ │ │ (Dato) │ │ (Dato) │ │ │ │ │ │ next ──────┼───→│ next ──────┼───→ NULL │ │ │ │ └──────────────┘ └──────────────┘ │ │ │ │ HEAD NODO 2 │ │ │ │ │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ EJEMPLO VISUAL: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ HEAD → [10|●] → [20|●] → [30|●] → [40|∅] │ │ │ │ ───┘ ───┘ ───┘ │ │ │ │ Nodo 1 Nodo 2 Nodo 3 Nodo 4 │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ VENTAJAS: │ │ ✅ Tamaño dinámico (crece y decrece) │ │ ✅ Inserción y eliminación eficiente O(1) │ │ ✅ No requiere memoria contigua │ │ │ │ DESVENTAJAS: │ │ ❌ No acceso aleatorio O(n) │ │ ❌ Mayor uso de memoria (punteros) │ │ ❌ Más complejo de implementar │ │ │ └─────────────────────────────────────────────────────────────────┘ ----------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ │ 💻 IMPLEMENTACIÓN DINÁMICA EN C │ │ │ │ CARACTERÍSTICAS: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ • Memoria asignada dinámicamente (malloc/calloc) │ │ │ │ • Tamaño ilimitado (hasta memoria disponible) │ │ │ │ • Mayor flexibilidad │ │ │ │ • Necesita liberar memoria (free) │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ CÓDIGO EN C: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ typedef struct Nodo { │ │ │ │ int dato; │ │ │ │ struct Nodo* next; │ │ │ │ } Nodo; │ │ │ │ │ │ │ │ Nodo* head = NULL; // Inicio de lista vacía │ │ │ │ │ │ │ │ // Crear un nuevo nodo │ │ │ │ Nodo* crearNodo(int dato) { │ │ │ │ Nodo* nuevo = (Nodo*)malloc(sizeof(Nodo)); │ │ │ │ nuevo->dato = dato; │ │ │ │ nuevo->next = NULL; │ │ │ │ return nuevo; │ │ │ │ } │ │ │ │ │ │ │ │ // Insertar al inicio │ │ │ │ void insertarInicio(int dato) { │ │ │ │ Nodo* nuevo = crearNodo(dato); │ │ │ │ nuevo->next = head; │ │ │ │ head = nuevo; │ │ │ │ } │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ 📌 ANÁLISIS: │ │ • Implementación más flexible y potente │ │ • Uso de punteros y memoria dinámica │ │ • Base para implementaciones en C++/Python │ │ │ └─────────────────────────────────────────────────────────────────┘ ----------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ │ 🔄 LISTAS CIRCULARES │ │ │ │ DEFINICIÓN: │ │ Una lista circular es similar a una lista enlazada, pero │ │ el último nodo apunta al primer nodo (en lugar de NULL). │ │ │ │ ESTRUCTURA: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ ┌─────────────────────────────────┐ │ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ │ ┌─────┐ ┌─────┐ ┌─────┐ │ │ │ │ │ │ 10 │ │ 20 │ │ 30 │ │ │ │ │ │ │ ●──┼───→│ ●──┼───→│ ●──┼────┘ │ │ │ │ └─────┘ └─────┘ └─────┘ │ │ │ │ HEAD │ │ │ │ │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ CARACTERÍSTICAS: │ │ ✅ No tiene NULL, el último apunta al primero │ │ ✅ Permite recorrido circular │ │ ✅ Útil para aplicaciones de turnos (round-robin) │ │ ✅ Inserción y eliminación eficientes │ │ │ │ APLICACIONES: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ • Planificación de procesos (Round Robin) │ │ │ │ • Juegos de mesa (turnos) │ │ │ │ • Buffers circulares │ │ │ │ • Listas de reproducción (playlists) │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────┘ ----------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ │ 🔄 LISTAS DOBLEMENTE ENLAZADAS │ │ │ │ DEFINICIÓN: │ │ Una lista doblemente enlazada tiene nodos con dos │ │ punteros: anterior y siguiente. │ │ │ │ ESTRUCTURA DE UN NODO: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ prev ┌──────────┐ next │ │ │ │ ────────│ DATOS │──────── │ │ │ │ │ └──────────┘ │ │ │ │ │ │ │ │ │ │ │ ▼ ▼ │ │ │ │ ┌─────┐ ┌─────┐ ┌─────┐ │ │ │ │ │ 10 │ │ 20 │ │ 30 │ │ │ │ │ │ ●──┼───→│ ●──┼───→│ ●──┼───→ NULL │ │ │ │ │ ●──┼───←│ ●──┼───←│ ●──┼───← NULL │ │ │ │ └─────┘ └─────┘ └─────┘ │ │ │ │ HEAD NODO 2 NODO 3 │ │ │ │ │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ VENTAJAS: │ │ ✅ Recorrido en ambas direcciones (forward/backward) │ │ ✅ Eliminación más fácil (conoces el nodo anterior) │ │ ✅ Inserción más flexible │ │ ✅ Mejor para algunas operaciones │ │ │ │ DESVENTAJAS: │ │ ❌ Mayor uso de memoria (dos punteros por nodo) │ │ ❌ Más complejo de implementar │ │ │ └─────────────────────────────────────────────────────────────────┘ ----------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ │ 📚 COLAS SOBRE LISTAS ENLAZADAS │ │ │ │ CONCEPTO: │ │ Usar una lista enlazada como estructura subyacente para │ │ implementar una cola (FIFO). │ │ │ │ ESTRUCTURA: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ FRONT REAR │ │ │ │ ↓ ↓ │ │ │ │ ┌─────┐ ┌─────┐ ┌─────┐ │ │ │ │ │ 10 │ │ 20 │ │ 30 │ │ │ │ │ │ ●──┼───→│ ●──┼───→│ ●──┼───→ NULL │ │ │ │ └─────┘ └─────┘ └─────┘ │ │ │ │ │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ VENTAJAS: │ │ ✅ Tamaño dinámico │ │ ✅ Enqueue O(1) │ │ ✅ Dequeue O(1) │ │ ✅ No hay desperdicio de memoria │ │ │ │ COMPARACIÓN: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ OPERACIÓN │ Cola con Array │ Cola con Lista │ │ │ ├───────────────┼──────────────────┼────────────────────┤ │ │ │ Enqueue │ O(1) │ O(1) │ │ │ │ Dequeue │ O(1) │ O(1) │ │ │ │ Front │ O(1) │ O(1) │ │ │ │ Espacio │ Fijo │ Dinámico │ │ │ │ Memoria │ Continua │ Dispersa │ │ │ └───────────────┴──────────────────┴────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────┘ ----------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ │ ⚖️ COMPARATIVA DE IMPLEMENTACIONES │ │ │ │ ┌────────────────────────────────────────────────────────────┐│ │ │ CARACTERÍST │ Array │ Lista │ Lista ││ │ │ ICA │ │ Simple │ Doble ││ │ ├───────────────┼────────────┼────────────┼───────────────┤│ │ │ Tamaño │ Fijo │ Dinámico │ Dinámico ││ │ │ Memoria │ Continua │ Dispersa │ Dispersa ││ │ │ Acceso O(1) │ Sí │ No │ No ││ │ │ Inserción │ O(n) │ O(1) │ O(1) ││ │ │ Eliminación │ O(n) │ O(1) │ O(1) ││ │ │ Recorrido │ O(n) │ O(n) │ O(n) ││ │ │ Bidireccional│ N/A │ No │ Sí ││ │ └───────────────┴────────────┴────────────┴───────────────┘│ │ │ │ PARA PILAS Y COLAS: │ │ ┌────────────────────────────────────────────────────────────┐│ │ │ ESTRUCTURA │ Array │ Lista Simple │ std::queue ││ │ │ Pila │ O(1) push │ O(1) push │ O(1) push ││ │ │ │ O(1) pop │ O(1) pop │ O(1) pop ││ │ │ │ Tamaño fijo│ Dinámico │ Dinámico ││ │ ├───────────────┼────────────┼───────────────┼─────────────┤│ │ │ Cola │ O(1) enc │ O(1) enc │ O(1) enc ││ │ │ │ O(1) desc │ O(1) desc │ O(1) desc ││ │ │ │ Circular │ Dinámica │ Dinámica ││ │ └───────────────┴────────────┴───────────────┴─────────────┘│ │ │ │ 📌 CUÁNDO USAR CADA UNA: │ │ • LISTA ENLAZADA: Cuando necesitas inserciones/eliminaciones │ │ frecuentes en el medio │ │ • LISTA CIRCULAR: Para aplicaciones de turnos/round-robin │ │ • LISTA DOBLE: Cuando necesitas recorrer en ambas direcciones│ │ • STACK/QUEUE: Usar std::stack/queue con list para memoria │ │ dinámica eficiente │ │ │ └─────────────────────────────────────────────────────────────────┘ Follow Design: {"palette":["Terminal Slate #0F172A — primary dark background","Syntax Cyan #38BDF8 — pointers, arrows, and highlight nodes","Memory Violet #A855F7 — secondary structures and data fields","Success Green #34D399 — positive complexity and pros","Alert Coral #F87171 — negative complexity and cons","Code Mist #F1F5F9 — primary typography and diagram labels","Panel Surface #1E293B — card and code block backgrounds"],"fonts":{"Inter":"https://fonts.googleapis.com/css2?family=Inter:ital,wght@0,100..900;1,100..900&display=swap","JetBrains Mono":"https://fonts.googleapis.com/css2?family=JetBrains+Mono:ital,wght@0,100..800;1,100..800&display=swap","Fira Code":"https://fonts.googleapis.com/css2?family=Fira+Code:wght@300..700&display=swap"},"type":"Inter SemiBold in uppercase with tracked-out spacing for section titles and slide headers; JetBrains Mono Regular for structural descriptions, bullet points, and complexity tags; Fira Code for raw C syntax and inline code terms with distinct color weights.","layout":"A 12-column modular split layout with 48px canvas padding, featuring a prominent 60/40 divide between structural memory diagrams on the left and analytical comparison breakdowns on the right.","framework_treatment":"Dark-mode container cards with 1px border outlines in slate gray, rounded node blocks connected by glowing SVG-like vector arrows, dedicated monospaced code panes with syntax highlighting, and dual-state advantage/disadvantage badge chips.","feels_like":"A premium Stripe developer documentation site meets an interactive MIT Computer Science visualization tool"}
Presentation overview
This community presentation was shared by Ronaldo Echeverría as a complete 7-slide example. ┌─────────────────────────────────────────────────────────────────┐ │ 📚 ¿QUÉ ES UNA LISTA ENLAZADA? │ │ │ │ DEFINICIÓN: │ │ Una lista enlazada es una estructura de datos dinámi… The preview lets you review the full sequence in order, rather than judging the design from a single cover image.
Use it as a reference for planning your own deck: notice how the amount of information changes from slide to slide, where visual emphasis appears, and how repeated design choices help the presentation feel connected. Community examples are inspiration, not locked templates, so you can keep the ideas that fit your audience and replace anything that does not.
Learn from the example
Look at the job each slide performs. Identify where the deck introduces its subject, develops the main points, adds evidence or examples, and moves toward a conclusion.
Notice which element attracts attention first and how headings, supporting text, images, and data are separated. Strong hierarchy makes the intended reading order obvious.
Compare spacing, typography, color, and repeated components across the slides. Consistent rules help varied content feel like one presentation instead of unrelated screens.
Make it your own
Begin with your audience and the decision, lesson, or action the presentation should support. Replace the topic, examples, evidence, and visuals with material you can verify, then edit every slide for one clear takeaway. You can borrow the visual direction without copying the creator's wording or message. Presenton will use this community deck as a design reference while you develop content for your own purpose.
