Loading...
Community presentation
┌─────────────────────────────────────────────────────────────────┐ │ 🌳 ¿QUÉ ES UN ÁRBOL? │ │ │ │ DEFINICIÓN: │ │ Un árbol es una estructura de datos jerárquica no lineal │ │ c…
Create your own version
Use this visual direction as inspiration for a new Presenton deck.
Use this designCreator prompt
┌─────────────────────────────────────────────────────────────────┐ │ 🌳 ¿QUÉ ES UN ÁRBOL? │ │ │ │ DEFINICIÓN: │ │ Un árbol es una estructura de datos jerárquica no lineal │ │ compuesta por nodos conectados por aristas (edges). │ │ │ │ CARACTERÍSTICAS: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ ✅ Tiene un nodo raíz (root) │ │ │ │ ✅ Cada nodo tiene 0 o más nodos hijos │ │ │ │ ✅ Cada nodo (excepto raíz) tiene un padre │ │ │ │ ✅ No hay ciclos │ │ │ │ ✅ Estructura jerárquica │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ ESTRUCTURA VISUAL: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 🌳 RAÍZ │ │ │ │ / \ │ │ │ │ 🌿 🌿 │ │ │ │ / \ / \ │ │ │ │ 🍃 🍃 🍃 🍃 │ │ │ │ │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ COMPARACIÓN CON LISTAS: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ LISTAS │ ÁRBOLES │ │ │ ├──────────────────────┼────────────────────────────────┤ │ │ │ Lineales │ Jerárquicos │ │ │ │ Un solo camino │ Múltiples caminos │ │ │ │ Un predecesor │ Un predecesor (padre) │ │ │ │ Un sucesor │ Múltiples sucesores (hijos) │ │ │ └──────────────────────┴────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────┘ ------------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ │ 📚 TERMINOLOGÍA DE ÁRBOLES │ │ │ │ DEFINICIONES CLAVE: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 🌳 RAÍZ (ROOT) → Nodo superior (sin padre) │ │ │ │ 🌿 PADRE (PARENT) → Nodo que tiene hijos │ │ │ │ 🍃 HIJO (CHILD) → Nodo que tiene un padre │ │ │ │ 🍂 HOJA (LEAF) → Nodo sin hijos │ │ │ │ 🌱 SUBÁRBOL → Árbol dentro del árbol │ │ │ │ 📏 NIVEL (LEVEL) → Distancia desde la raíz │ │ │ │ 📐 ALTURA (HEIGHT) → Nivel máximo del árbol │ │ │ │ 📊 GRADO (DEGREE) → Número de hijos de un nodo │ │ │ │ 👨👧👦 HERMANOS (SIBLINGS) → Nodos con mismo padre │ │ │ │ 👣 ANCESTROS → Nodos desde raíz hasta nodo │ │ │ │ 👦 DESCENDIENTES → Nodos desde nodo hacia hojas │ │ │ │ 🔗 ARISTA (EDGE) → Conexión entre nodos │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ EJEMPLO VISUAL: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 🌳 A (RAÍZ) - Nivel 0 │ │ │ │ / \ │ │ │ │ 🌿 B 🌿 C - Nivel 1 │ │ │ │ / \ / \ │ │ │ │ 🍃 D 🍃 E 🍃 F 🍃 G - Nivel 2 │ │ │ │ │ │ │ │ • Altura = 2 (niveles 0,1,2) │ │ │ │ • Grado de A = 2, Grado de B = 2, Grado de D = 0 │ │ │ │ • Hojas: D, E, F, G │ │ │ │ • Hermanos: B y C, D y E, F y G │ │ │ │ • Ancestros de E: A, B │ │ │ │ • Descendientes de B: D, E │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────┘ ------------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ │ 🎨 REPRESENTACIÓN GRÁFICA DE ÁRBOLES │ │ │ │ FORMAS DE REPRESENTAR: "EJEMPLO" │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 1. DIAGRAMA DE ÁRBOL (Estructura jerárquica) │ │ │ │ 📁 Raíz │ │ │ │ / \ │ │ │ │ 📁 📁 │ │ │ │ / \ / \ │ │ │ │ 📄 📄 📄 📄 │ │ │ │ │ │ │ │ 2. NOTACIÓN PARENTÉTICA │ │ │ │ Raíz(Hijo1, Hijo2(Hijo2.1, Hijo2.2), Hijo3) │ │ │ │ │ │ │ │ 3. REPRESENTACIÓN EN LISTA DE ADYACENCIA │ │ │ │ Raíz → [Hijo1, Hijo2, Hijo3] │ │ │ │ Hijo1 → [Hijo1.1, Hijo1.2] │ │ │ │ Hijo2 → [] │ │ │ │ │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ EJEMPLO DE ÁRBOL GENEALÓGICO: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 👴 Abuelo │ │ │ │ / \ │ │ │ │ 👨 👨 │ │ │ │ / \ / \ │ │ │ │ 👦 👦 👦 👦 │ │ │ │ │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────┘ ------------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ │ 🌳 ÁRBOLES BINARIOS (AB) - 'EJEMPLO' │ │ │ │ DEFINICIÓN: │ │ Un árbol binario es un árbol donde cada nodo tiene como │ │ máximo DOS hijos: hijo izquierdo e hijo derecho. │ │ │ │ ESTRUCTURA: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 🌳 RAÍZ │ │ │ │ / \ │ │ │ │ 🌿 🌿 │ │ │ │ / \ / \ │ │ │ │ 🍃 🍃 🍃 🍃 │ │ │ │ │ │ │ │ • Cada nodo tiene 0, 1 o 2 hijos │ │ │ │ • Hijo izquierdo (subárbol izquierdo) │ │ │ │ • Hijo derecho (subárbol derecho) │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ PROPIEDADES: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ • Máximo número de nodos en nivel n: 2^n │ │ │ │ • Máximo número de nodos en altura h: 2^(h+1) - 1 │ │ │ │ • Número de hojas: (n+1)/2 (para completo) │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ TIPOS DE ÁRBOLES BINARIOS: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ 1. ÁRBOL BINARIO COMPLETO │ │ │ │ 2. ÁRBOL BINARIO LLENO (Perfecto) │ │ │ │ 3. ÁRBOL BINARIO BALANCEADO │ │ │ │ 4. ÁRBOL BINARIO DE BÚSQUEDA (BST) │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────┘ ------------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ ⚖️ EQUILIBRIO EN ÁRBOLES BINARIOS │ │ │ │ DEFINICIÓN: │ │ Un árbol binario está balanceado si la diferencia de │ │ altura entre los subárboles izquierdo y derecho de cada │ │ nodo no es mayor a 1. │ │ │ │ EJEMPLOS: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ ÁRBOL BALANCEADO ✅ ÁRBOL NO BALANCEADO ❌│ │ │ │ │ │ │ │ 1 1 │ │ │ │ / \ / │ │ │ │ 2 3 2 │ │ │ │ / \ / │ │ │ │ 4 5 3 │ │ │ │ / │ │ │ │ 4 │ │ │ │ │ │ │ │ Altura(Izq)=2, Altura(Der)=2 Altura(Izq)=3, │ │ │ │ Diferencia = 0 Altura(Der)=0 │ │ │ │ ✅ Balanceado Diferencia = 3 ❌ │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ TIPOS DE ÁRBOLES BALANCEADOS: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ • Árbol AVL (Adelson-Velsky y Landis) │ │ │ │ • Árbol Rojo-Negro │ │ │ │ • Árbol Splay │ │ │ │ • Árbol B (B-tree) │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ IMPORTANCIA DEL EQUILIBRIO: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ • Garantiza operaciones O(log n) │ │ │ │ • Evita que el árbol se degrade a una lista │ │ │ │ • Mejor rendimiento en búsquedas │ │ │ │ • Ideal para bases de datos e índices │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────┘ ------------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ │ 🌳 ÁRBOLES BINARIOS COMPLETOS │ │ │ │ DEFINICIÓN: │ │ Un árbol binario es COMPLETO si todos los niveles están │ │ completamente llenos, excepto posiblemente el último, │ │ y los nodos del último nivel están lo más a la izquierda │ │ posible. │ │ │ │ EJEMPLOS VISUALES: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ COMPLETO ✅ NO COMPLETO ❌ │ │ │ │ │ │ │ │ 1 1 │ │ │ │ / \ / \ │ │ │ │ 2 3 2 3 │ │ │ │ / \ / / \ │ │ │ │ 4 5 6 4 5 │ │ │ │ │ │ │ │ COMPLETO ✅ NO COMPLETO ❌ │ │ │ │ │ │ │ │ 1 1 │ │ │ │ / \ / \ │ │ │ │ 2 3 2 3 │ │ │ │ / / / \ │ │ │ │ 4 4 5 6 │ │ │ │ │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ PROPIEDADES: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ • Si tiene n nodos, altura = ⌈log₂(n+1)⌉ │ │ │ │ • Puede representarse eficientemente con un array │ │ │ │ • Ideal para heaps (montículos) │ │ │ │ • Inserción y eliminación eficiente │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ REPRESENTACIÓN EN ARRAY: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Árbol: Array: │ │ │ │ │ │ │ │ 1 [1, 2, 3, 4, 5, 6] │ │ │ │ / \ ↑ ↑ ↑ ↑ ↑ ↑ │ │ │ │ 2 3 Índices: 0 1 2 3 4 5 │ │ │ │ / \ / │ │ │ │ 4 5 6 │ │ │ │ │ │ │ │ • Hijo izquierdo en posición 2*i+1 │ │ │ │ • Hijo derecho en posición 2*i+2 │ │ │ │ • Padre en posición (i-1)/2 │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────┘ ------------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ │ 📚 TAD ÁRBOL BINARIO - ESPECIFICACIÓN │ │ │ │ OPERACIONES PRIMITIVAS: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 📌 CONSTRUCTOR / DESTRUCTOR │ │ │ │ ┌──────────────────────────────────────────────────┐ │ │ │ │ │ ArbolBinario() │ │ │ │ │ │ ArbolBinario(dato) │ │ │ │ │ │ ~ArbolBinario() │ │ │ │ │ └──────────────────────────────────────────────────┘ │ │ │ │ │ │ │ │ 📌 OPERACIONES DE CONSULTA │ │ │ │ ┌──────────────────────────────────────────────────┐ │ │ │ │ │ estaVacio() → bool │ │ │ │ │ │ raiz() → T │ │ │ │ │ │ hijoIzquierdo() → T │ │ │ │ │ │ hijoDerecho() → T │ │ │ │ │ │ altura() → int │ │ │ │ │ │ tamaño() → int │ │ │ │ │ │ esCompleto() → bool │ │ │ │ │ │ esBalanceado() → bool │ │ │ │ │ └──────────────────────────────────────────────────┘ │ │ │ │ │ │ │ │ 📌 OPERACIONES DE MODIFICACIÓN │ │ │ │ ┌──────────────────────────────────────────────────┐ │ │ │ │ │ insertarIzquierdo(nodo, dato) │ │ │ │ │ │ insertarDerecho(nodo, dato) │ │ │ │ │ │ eliminarNodo(dato) │ │ │ │ │ │ vaciar() │ │ │ │ │ └──────────────────────────────────────────────────┘ │ │ │ │ │ │ │ │ 📌 RECORRIDOS │ │ │ │ ┌──────────────────────────────────────────────────┐ │ │ │ │ │ preorden() → Lista<T> │ │ │ │ │ │ inorden() → Lista<T> │ │ │ │ │ │ postorden() → Lista<T> │ │ │ │ │ │ porNiveles() → Lista<T> │ │ │ │ │ └──────────────────────────────────────────────────┘ │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ EJEMPLO DE ESPECIFICACIÓN EN C++: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ template <typename T> │ │ │ │ class IArbolBinario { │ │ │ │ public: │ │ │ │ virtual bool estaVacio() const = 0; │ │ │ │ virtual T obtenerRaiz() const = 0; │ │ │ │ virtual int altura() const = 0; │ │ │ │ virtual int tamano() const = 0; │ │ │ │ virtual void insertarIzquierdo(T dato) = 0; │ │ │ │ virtual void insertarDerecho(T dato) = 0; │ │ │ │ virtual vector<T> preorden() const = 0; │ │ │ │ virtual vector<T> inorden() const = 0; │ │ │ │ virtual vector<T> postorden() const = 0; │ │ │ │ virtual vector<T> porNiveles() const = 0; │ │ │ │ }; │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────┘ ------------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ │ 💻 EJEMPLO VIDA REAL: SISTEMA DE ARCHIVOS │ │ │ │ PROBLEMA: Representar la estructura de directorios de un │ │ sistema operativo usando árboles. │ │ │ │ ESTRUCTURA DEL SISTEMA DE ARCHIVOS: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ 📁 C:/ │ │ │ │ / \ │ │ │ │ 📁 Usuarios 📁 Program Files │ │ │ │ / | \ / | \ │ │ │ │ 📁 Ana 📁 Juan 📁 María 📁 Office 📁 Games 📁 Tools│ │ │ │ | | | | | | │ │ │ │ 📄 doc1 📄 doc2 📄 doc3 📄 word 📄 sol 📄 calc │ │ │ │ │ │ │ └────────────────────────────────────────────────────────┘ │ │ │ │ CÓDIGO EN PYTHON: │ │ ┌────────────────────────────────────────────────────────┐ │ │ │ class NodoArchivo: │ │ │ │ def __init__(self, nombre, es_directorio): │ │ │ │ self.nombre = nombre │ │ │ │ self.es_directorio = es_directorio │ │ │ │ self.hijos = [] │ │ │ │ self.tamanio = 0 │ │ │ │ │ │ │ │ class SistemaArchivos: │ │ │ │ def __init__(self): │ │ │ │ self.raiz = NodoArchivo("C:", True) │ │ │ │ │ │ │ │ def crear_directorio(self, padre, nombre): │ │ │ │ nuevo = NodoArchivo(nombre, True) │ │ │ │ padre.hijos.append(nuevo) │ │ │ │ │ │ │ │ def crear_archivo(self, padre, nombre, tam): │ │ │ │ nuevo = NodoArchivo(nombre, False) │ │ │ │ nuevo.tamanio = tam │ │ │ │ padre.hijos.append(nuevo) │ │ │ │ │ │ │ │ def mostrar_estructura(self, nodo, nivel=0): │ │ │ │ indent = " " * nivel │ │ │ │ icono = "📁" if nodo.es_directorio else "📄" │ │ │ │ print(f"{indent}{icono} {nodo.nombre}") │ │ │ │ for hijo in nodo.hijos: │ │ │ │ self.mostrar_estructura(hijo, nivel+1)│ │ │ └────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────┘ ------------------------------------------------------------------------------------------------------------------------- ┌─────────────────────────────────────────────────────────────────┐ │ ✏️ EJERCICIO PRÁCTICO (15 minutos) │ │ │ │ PROBLEMA: ÁRBOL GENEALÓGICO CON ÁRBOLES BINARIOS │ │ │ │ 📌 REQUISITOS: │ │ │ │ 1. Crear un árbol genealógico usando un árbol binario: │ │ • Cada persona tiene padre y madre (hijos izquierdo/derecho)│ │ • Almacenar: nombre, edad, género │ │ │ │ 2. Implementar: │ │ • Insertar persona (como hijo de otra) │ │ • Buscar persona por nombre │ │ • Mostrar árbol genealógico completo │ │ • Calcular profundidad de una persona │ │ • Contar descendientes de una persona │ │ │ │ 3. Datos de prueba: │ │ • Abuelo: Juan (75 años) │ │ • Abuela: María (72 años) │ │ • Padre: Carlos (50 años) │ │ • Madre: Ana (48 años) │ │ • Hijos: Luis (25), Sofía (22), Pedro (20) │ │ │ │ 4. Extensiones (opcional): │ │ • Verificar si el árbol está balanceado │ │ • Encontrar el abuelo más joven │ │ • Calcular promedio de edad del árbol │ │ │ │ 💡 PISTAS: │ │ • Usar la clase NodoBinario implementada │ │ • El hijo izquierdo = padre, derecho = madre │ │ • Usar recursión para recorridos │ │ • Almacenar objetos Persona en los nodos │ │ │ │ │ └─────────────────────────────────────────────────────────────────┘ Follow Design: {"palette":["Deep slate #0F172A — primary text and structural borders","Algorithmic emerald #059669 — valid states, leaf nodes, and success tags","Binary cobalt #2563EB — primary brand accents and root indicators","Muted stone #64748B — secondary labels and connecting edge lines","Soft canvas gray #F8FAFC — clean slide background","Alert crimson #DC2626 — invalid trees and warning states"],"fonts":{"Plus Jakarta Sans":"https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:ital,wght@0,200..800;1,200..800&display=swap","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"},"type":"Plus Jakarta Sans in Bold and SemiBold for crisp lecture headings; Inter Regular and Medium for conceptual explanations; JetBrains Mono for tree notation, method signatures, complexity metrics, and code blocks.","layout":"Structured modular grid with split-pane layouts; left column reserved for conceptual definitions and operations, right column dedicated to visual tree hierarchies and array mapping diagrams.","framework_treatment":"Crisp white cards with hairline borders (1px #E2E8F0), pill-shaped badge chips for tree nodes (Root, Child, Leaf), syntax-highlighted code panels, and dotted connector lines for branch hierarchies.","feels_like":"A premium developer documentation portal meets interactive computer science lecture slides"}
Presentation overview
This community presentation was shared by EDGAR RONALDO ECHEVERRIA BARDALES as a complete 10-slide example. ┌─────────────────────────────────────────────────────────────────┐ │ 🌳 ¿QUÉ ES UN ÁRBOL? │ │ │ │ DEFINICIÓN: │ │ Un árbol es una estructura de datos jerárquica no lineal │ │ c… 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.
