EDA — Estructuras de Datos y Algoritmos

Enunciado: Defina árbol binario completo, montículo, árbol binario de búsqueda y árbol AVL.

Árbol binario completo

Un árbol binario es completo si todos los niveles están llenos excepto posiblemente el último, que se rellena de izquierda a derecha. Esto permite representarlo eficientemente en un array: el hijo izquierdo del nodo i está en la posición 2i+1 y el hijo derecho en 2i+2 (con índice base 0).

Montículo (Heap)

Un montículo es un árbol binario completo que satisface la propiedad de montículo: en un max-heap cada padre es ≥ que sus hijos; en un min-heap cada padre es ≤ que sus hijos. La raíz siempre contiene el máximo (o mínimo).

Operaciones: inserción O(log n) con sift-up; eliminación del extremo O(log n) con sift-down; construcción desde array O(n).

Árbol Binario de Búsqueda (BST)

Árbol binario donde para cada nodo N: todos los valores del subárbol izquierdo son menores que N, y todos los del subárbol derecho son mayores. El recorrido inorden produce los valores en orden ascendente.

Búsqueda, inserción y eliminación: O(log n) en promedio, O(n) en el peor caso (árbol degenerado).

Árbol AVL

BST auto-equilibrado donde en cada nodo la diferencia de alturas entre subárbol izquierdo y derecho (Factor de Equilibrio, FE) es −1, 0 o +1. Tras cada inserción o eliminación, si algún nodo rompe esta condición se aplica una rotación (simple o doble) para reequilibrar.

Tipos de rotación: LL → rotación simple derecha | RR → rotación simple izquierda | LR → doble (der-der, luego izquierda) | RL → doble (izq-izq, luego derecha).
Búsqueda, inserción, eliminación: siempre O(log n).

Resumen de complejidades:
BST promedio: O(log n) — BST peor caso: O(n) — AVL siempre: O(log n)
Heap inserción: O(log n) — Heap construcción desde array: O(n)

Enunciado: Dado un árbol AVL cuyo recorrido por niveles es:
59 15 68 3 21 67 82 8 16 51 81 98 40
1) Recorridos inorden, preorden y postorden. 2) Insertar 47, 73, 54. 3) Eliminar 67 y 82 del árbol inicial.

El recorrido por niveles se lee fila a fila de arriba abajo. Así queda el árbol:

Parte 1 — Recorridos

Paso 0 / 13

Pulsa "Siguiente" para empezar el recorrido.

Orden de visita: —

Parte 2 — Insertar 47, 73, 54 (sobre el árbol inicial)

Paso 0 / 9

Pulsa "Siguiente" para comenzar la inserción de 47, 73 y 54.

—

       Nodo nuevo / insertado
       Nodo rotado / recolocado
       Nodo desequilibrado
       Raíz
    

Insertar 47

Ruta de inserción: 47 < 59 → izq → 47 > 15 → der → 47 > 21 → der → 47 < 51 → izq → 47 > 40 → der. Se inserta como hijo derecho de 40.

Revisión de FE (Factor de Equilibrio = h_izq − h_der) hacia arriba:
FE(51) = 1−0 = +1 ✓
FE(21) = 0−2 = −2 ❌ desequilibrio. El hijo derecho (51) tiene peso hacia su derecha → caso derecha-derecha (RR) → Rotación simple izquierda en 21.
51 sube: hijo izq de 51 = 21; hijo der de 51 = 47 (era hijo der de 40). 40 queda hijo izq de 47.
Árbol reequilibrado: FE(51)=0, FE(15)=−1 ✓

Insertar 73 (sobre árbol tras insertar 47)

Ruta: 73 > 59 → der → 73 > 68 → der → 73 < 82 → izq → 73 < 81 → izq. Se inserta como hijo izquierdo de 81.

Revisión FE hacia arriba:
FE(81) = +1 ✓ | FE(82) = +2−1 = +1 ✓ | FE(68) = −1 ✓
Ningún nodo llega a ±2 → Sin rotación. El árbol sigue equilibrado.

Insertar 54 (sobre árbol tras 47 y 73)

Ruta: 54 < 59 → izq → 54 > 15 → der → 54 > 51 → der. Se inserta como hijo derecho de 51.

Revisión FE hacia arriba:
FE(51) = 0−1 = −1 ✓ | FE(21 o su padre actual) se propaga…
No se produce desequilibrio en este caso: FE(15) = −1−0→ se ajusta pero no supera ±2 con la estructura resultante de la inserción de 47.
→ Sin rotación. 54 se inserta directamente.

Parte 3 — Eliminar 67 y 82 (del árbol INICIAL, sin las inserciones)

Eliminar 67

Tipo de nodo: 67 es un nodo hoja (sin hijos). Se elimina directamente sin necesidad de sucesor.

Revisión FE hacia arriba:
FE(68) = h_izq − h_der = 0 − 1 = −1 ✓ (válido, no hay rotación).
El árbol sigue siendo AVL.

Eliminar 82 (del árbol inicial, 67 todavía presente)

Tipo de nodo: 82 tiene dos hijos (81 izq, 98 der). Se aplica la regla del sucesor inorden (el mínimo del subárbol derecho).

Sucesor inorden de 82 = nodo más pequeño del subárbol derecho = 98 (único hijo derecho, sin hijos propios).
→ Se copia el valor 98 en la posición de 82, y se elimina el nodo hoja 98.
Resultado: donde había 82 ahora hay 98, con hijo izquierdo 81.

Revisión FE:
FE(98_nuevo) = 1 − 0 = +1 ✓ | FE(68) = h_izq − h_der: con 67 y el nuevo 98 → FE = 0 ✓
→ Sin rotación. Árbol AVL válido.

Parte 3 — Eliminar 90 y 8 (del árbol INICIAL)

Paso 0 / 6

Pulsa "Siguiente" para comenzar la eliminación de 90 y 8.

—

       Nodo eliminado
       Sucesor inorden / recolocado
       Afectado por rebalanceo
    

Inorden: 8 → 9 → 13 → 16 → 18 → 19 → 21 → 26 → 61 → 67 → 77 → 89 → 90
Preorden: 18 → 9 → 8 → 16 → 13 → 21 → 19 → 77 → 26 → 61 → 67 → 89 → 90
Postorden: 8 → 13 → 16 → 9 → 19 → 21 → 67 → 61 → 26 → 90 → 89 → 77 → 18

Enunciado: Aplicar heapsort sobre: 30, 7, 8, 45, 98, 72, 91, 25, 73, 12

¿Qué es heapsort?

Idea general

Heapsort tiene dos fases: primero construye un max-heap (árbol donde cada padre es mayor que sus hijos), y luego extrae el máximo repetidamente colocándolo al final del array.

Fase 1 — Construir el max-heap

Empezamos heapify desde el índice n/2−1 = 4 hacia la izquierda:

i=4

Valor 98, hijos: 73 y 12

98 es mayor que ambos hijos → sin intercambio.

i=3

Valor 45, hijos: 25 y 73

73 > 45 → intercambio(45, 73)

i=2

Valor 8, hijos: 72 y 91

91 > 8 → intercambio(8, 91). El 8 baja a pos 6, sin más hijos en rango.

i=1

Valor 7, hijos: 73 y 98

98 > 7 → intercambio(7, 98). El 7 baja a pos 4, hijos: 45 y 12. 45 > 7 → intercambio(7, 45). El 7 baja a pos 8, sin más hijos.

i=0

Valor 30, hijos: 98 y 91

98 > 30 → intercambio(30, 98). Baja a pos 1, hijos: 73 y 45. 73 > 30 → intercambio(30, 73). Baja a pos 3, hijos: 25 y 7. 30 > ambos → fin.

✓ Max-heap construido: 98, 73, 91, 30, 45, 72, 8, 25, 7, 12

Fase 2 — Extracción ordenada

swap(98, 12) → heapify [0..8]

swap(91, 7) → heapify [0..7]

swap(73, 25) → heapify [0..6]

swap(72, 8) → heapify [0..5]

swap(45, 7) → heapify [0..4]

swap(30, 7) → heapify [0..3]

swap(25, 7) → heapify [0..2]

swap(12, 8) → heapify [0..1]

swap(8, 7) → fin

Resultado ordenado: 7, 8, 12, 25, 30, 45, 72, 73, 91, 98

Enunciado: Para el grafo dado (nodos A,B,C,D,E,F,G,H,I): a) Matriz de adyacencia, b) Listas de adyacencia, c) DFS, d) BFS, e) Clasificación topológica.

a) Aristas del grafo

B→H, B→G, H→D, H→E, H→C, D→E, E→C, G→I, G→F, I→F, F→C, F→A, C→A

a) Matriz de adyacencia

	A	C	D	E	F	G	H	I
A	0	0	0	0	0	0	0	0
B	0	0	0	0	0	1	1	0
C	1	0	0	0	0	0	0	0
D	0	0	0	1	0	0	0	0
E	0	1	0	0	0	0	0	0
F	1	1	0	0	0	0	0	0
G	0	0	0	0	1	0	0	1
H	0	1	1	1	0	0	0	0
I	0	0	0	0	1	0	0	0

b) Listas de adyacencia

A: —
B: → G → H
C: → A
D: → E
E: → C
F: → A → C
G: → F → I
H: → C → D → E
I: → F

c) DFS — desde B (menor con grado entrada 0)

→

Regla: siempre elegir el vecino menor alfabéticamente

Pila inicial: [B]. Visito B → vecinos G, H → elijo G primero.
B → G (vecinos F, I → F primero) → F (vecinos A, C → A primero) → A (sin vecinos sin visitar, retrocedo) → C (sin vecinos sin visitar, retrocedo a F) → retrocedo a G → I → F (ya visitado, retrocedo) → retrocedo a B → H → C (visitado) → D → E → C (visitado, retrocedo) → fin.

DFS: B → G → F → A → C → I → H → D → E

d) BFS — desde B

→

Cola FIFO, vecinos en orden alfabético

Cola: [B]. Proceso B → encolo G, H. Cola: [G, H].
Proceso G → encolo F, I. Cola: [H, F, I].
Proceso H → encolo C, D, E (G ya visitado). Cola: [F, I, C, D, E].
Proceso F → A (C ya encolado). Cola: [I, C, D, E, A].
Proceso I → F ya visitado. Cola: [C, D, E, A].
Proceso C → A ya encolado. Proceso D, E, A → sin nuevos.

BFS: B → G → H → F → I → C → D → E → A

e) Clasificación topológica (Kahn)

→

Algoritmo: eliminar nodos con grado entrada 0 repetidamente

Grados entrada: A=3, B=0, C=4, D=1, E=2, F=2, G=1, H=1, I=1.
Solo B tiene grado 0 → sacamos B, reducimos grados de G y H.
Ahora G=0, H=0 → sacamos G (menor), reducimos F e I → sacamos H, reducimos C, D, E.
I=0 → sacamos I, reduce F → F=0 → sacamos F, reduce A y C → D=0, E=0 → sacamos D → reduce E ya en 0 → sacamos E, reduce C → C=0 → sacamos C, reduce A → A=0 → sacamos A.

Topológico: B → G → H → I → D → E → F → C → A

Enunciado: Inorden: a b c d e f g h i j k l m — Postorden: c e d b a f i h l k m j g. Construya el árbol binario.

Técnica: postorden da la raíz; inorden separa izquierda y derecha

El último elemento del postorden es siempre la raíz. En el inorden, todo lo que queda a su izquierda forma el subárbol izquierdo y todo lo que queda a la derecha forma el subárbol derecho. Aplicamos esto recursivamente.

Raíz del árbol completo

Postorden: [c e d b a f i h l k m j g] → raíz = g
En inorden, g está en posición 6: [a b c d e f | g | h i j k l m]
→ Subárbol izquierdo de g: {a,b,c,d,e,f} | Subárbol derecho: {h,i,j,k,l,m}

Subárbol izquierdo de g: {a,b,c,d,e,f}

Postorden de este subárbol: [c e d b a f] → raíz = f
En inorden: [a b c d e | f] → izq de f: {a,b,c,d,e}, der de f: vacío.

Postorden de {a,b,c,d,e}: [c e d b a] → raíz = a
En inorden: [| a | b c d e] → izq de a: vacío, der de a: {b,c,d,e}.

Postorden de {b,c,d,e}: [c e d b] → raíz = b
En inorden: [| b | c d e] → izq de b: vacío, der de b: {c,d,e}.

Postorden de {c,d,e}: [c e d] → raíz = d
En inorden: [c | d | e] → izq de d: {c}, der de d: {e}. Ambos son hojas.

Subárbol derecho de g: {h,i,j,k,l,m}

Postorden de este subárbol: [i h l k m j] → raíz = j
En inorden: [h i | j | k l m] → izq de j: {h,i}, der de j: {k,l,m}.

Subárbol {h,i}: postorden [i h] → raíz = h. Inorden: [h | i] (recordando que i > h → i es hijo derecho)... pero el inorden dice [h i], así que h izq vacío, der = {i}. Raíz = h, hijo derecho i.

Subárbol {k,l,m}: postorden [l k m] → raíz = m. Inorden: [k l | m] → izq de m: {k,l}, der de m: vacío.
{k,l}: postorden [l k] → raíz = k. Inorden: [k | l] → der de k = l.

Árbol resultante:

Verificación inorden (izq→raíz→der): c d e b a f | g | h i j k l m ✓
Verificación postorden (izq→der→raíz): c e d b a f i h l k m j g ✓

Enunciado: El recorrido por niveles de un BST es: 52, 19, 74, 14, 22, 56, 78, 11, 16, 21, 69, 13, 60. Dibuje el árbol.

Técnica: el recorrido por niveles se lee fila a fila

El recorrido BFS (por niveles) nos da los nodos de arriba a abajo, de izquierda a derecha. Para reconstruir el BST, simplemente insertamos cada valor en orden: el primero es la raíz, y cada siguiente se inserta siguiendo la propiedad BST (menores a la izquierda, mayores a la derecha).

Inserción ordenada: 52 → 19 → 74 → 14 → 22 → 56 → 78 → 11 → 16 → 21 → 69 → 13 → 60

• 52: raíz
• 19 < 52 → hijo izquierdo de 52
• 74 > 52 → hijo derecho de 52
• 14 < 52 → izq; < 19 → hijo izq de 19
• 22 < 52 → izq; > 19 → hijo der de 19
• 56 > 52 → der; < 74 → hijo izq de 74
• 78 > 52 → der; > 74 → hijo der de 74
• 11 < 52 < 19; < 14 → hijo izq de 14
• 16 < 52; < 19; > 14 → hijo der de 14
• 21 < 52; > 19; < 22 → hijo izq de 22
• 69 > 52; < 74; > 56 → hijo der de 56
• 13 < 52; < 19; < 14; > 11 → hijo der de 11
• 60 > 52; < 74; > 56; < 69 → hijo izq de 69

        
        52
        
        19
        
        74
        
        14
        
        22
        
        56
        
        78
        
        11
        
        16
        
        21
        
        69
        
        13
        
        60
      
      Inorden: 11, 13, 14, 16, 19, 21, 22, 52, 56, 60, 69, 74, 78 (orden ascendente ✓)

Enunciado (EJ 7): El recorrido en inorden de un montículo es: 3, 4, 0, 7, 5, 6, 9, 1, 8, 2. Dibuje el montículo. Luego inserte los valores 10 y 11.

Idea clave: un montículo es un árbol binario COMPLETO

La forma del árbol está completamente fijada por el número de nodos — no hay que deducirla. Con 10 nodos, el árbol tiene: nivel 0 → 1 nodo (raíz), nivel 1 → 2 nodos, nivel 2 → 4 nodos, nivel 3 → 3 nodos (el último nivel se rellena de izquierda a derecha).

El recorrido inorden (izq → raíz → der) visita cada nodo en un orden fijo determinado solo por la forma. Con esa forma y el inorden dado, podemos recuperar qué valor hay en cada posición del array.

Orden de visita del inorden para 10 nodos

En el árbol completo de 10 nodos, el inorden visita las posiciones del array (índice base 0) en este orden:
7 → 3 → 8 → 1 → 9 → 4 → 0 → 5 → 2 → 6

Esto se obtiene siguiendo: izquierdo más profundo del subárbol izq, luego raíz del subárbol, luego derecha. La pos 7 es hoja izq de pos 3; pos 3 es el izq del nivel 1; pos 8 es hoja der de pos 3; pos 1 es la raíz del subárbol izq; pos 9 es hoja izq de pos 4; pos 4 es el der del nivel 2 izq; pos 0 es la raíz global; pos 5,2,6 forman el subárbol derecho.

Asignar valores del inorden a las posiciones

El inorden dado es [3, 4, 0, 7, 5, 6, 9, 1, 8, 2]. Asignamos el i-ésimo valor a la i-ésima posición visitada:

Visita #	1	2	3	4	5	6	7	8	9	10
Pos del array	7	3	8	1	9	4	0	5	2	6
Valor	3	4	0	7	5	6	9	1	8	2

Array resultante: [9, 7, 8, 4, 6, 1, 2, 3, 0, 5]

Verificación propiedad max-heap (cada padre ≥ hijos):
pos 0 = 9: hijos pos1=7 y pos2=8 → 9≥7✓ 9≥8✓
pos 1 = 7: hijos pos3=4 y pos4=6 → 7≥4✓ 7≥6✓
pos 2 = 8: hijos pos5=1 y pos6=2 → 8≥1✓ 8≥2✓
pos 3 = 4: hijos pos7=3 y pos8=0 → 4≥3✓ 4≥0✓
pos 4 = 6: hijo pos9=5 → 6≥5✓ ✅ Es un max-heap válido.

Árbol resultante

Insertar 10: sift-up desde pos 10

10 se añade en pos 10 (hijo izq de pos 4 = 6). Sift-up:
padre(10) = pos ⌊(10−1)/2⌋ = pos 4 = 6. Como 10 > 6 → intercambio. 10 sube a pos 4.
padre(4) = pos ⌊(4−1)/2⌋ = pos 1 = 7. Como 10 > 7 → intercambio. 10 sube a pos 1.
padre(1) = pos ⌊(1−1)/2⌋ = pos 0 = 9. Como 10 > 9 → intercambio. 10 sube a raíz.
Array: [10, 9, 8, 4, 7, 1, 2, 3, 0, 5, 6]

Insertar 11: sift-up desde pos 11

11 se añade en pos 11 (hijo der de pos 5 = 1). Sift-up:
padre(11) = pos ⌊(11−1)/2⌋ = pos 5 = 1. Como 11 > 1 → intercambio. 11 sube a pos 5.
padre(5) = pos ⌊(5−1)/2⌋ = pos 2 = 8. Como 11 > 8 → intercambio. 11 sube a pos 2.
padre(2) = pos ⌊(2−1)/2⌋ = pos 0 = 10. Como 11 > 10 → intercambio. 11 sube a raíz.
Array final: [11, 9, 10, 4, 7, 8, 2, 3, 0, 5, 6, 1]

Montículo reconstruido: [9, 7, 8, 4, 6, 1, 2, 3, 0, 5] — raíz = 9 (máximo)
Verificación inorden: visitar posiciones 7,3,8,1,9,4,0,5,2,6 → valores 3,4,0,7,5,6,9,1,8,2 ✓
Tras insertar 10: [10, 9, 8, 4, 7, 1, 2, 3, 0, 5, 6]
Tras insertar 11: [11, 9, 10, 4, 7, 8, 2, 3, 0, 5, 6, 1]

Enunciado: Inserte consecutivamente los valores 17, 52, 71, 92, 98, 38 sobre un montículo mínimo inicialmente vacío. Sobre el montículo resultante, realice la operación eliminar tres veces.

Regla de inserción en min-heap

Se inserta al final (último nivel, de izquierda a derecha) y se hace sift-up: se compara el nodo con su padre; si es menor, se intercambian. Se repite hasta que el padre sea menor o se llegue a la raíz.

Regla de eliminación del mínimo: Se extrae la raíz, se coloca el último elemento en su lugar, y se hace sift-down: se intercambia con el hijo menor hasta recuperar la propiedad.

Fase 1 — Inserciones

+17

Insertar 17

Montículo vacío → 17 es la raíz. Sin sift-up necesario.

Array: [17]

+52

Insertar 52

Se inserta a la derecha de 17. Padre de pos 1 = pos 0 → 17. 52 ≥ 17 → sin intercambio.

Array: [17, 52]

+71

Insertar 71

Se inserta en pos 2 (hijo derecho de 17). Padre = 17. 71 ≥ 17 → sin intercambio.

Array: [17, 52, 71]

+92

Insertar 92

Pos 3 = hijo izquierdo de 52. Padre = 52. 92 ≥ 52 → sin intercambio.

Array: [17, 52, 71, 92]

+98

Insertar 98

Pos 4 = hijo derecho de 52. Padre = 52. 98 ≥ 52 → sin intercambio.

Array: [17, 52, 71, 92, 98]

+38

Insertar 38 — ¡Requiere sift-up!

Pos 5 = hijo izquierdo de 71. Padre = 71. 38 < 71 → intercambio(38, 71).
Ahora pos 2, padre = 17. 38 ≥ 17 → fin.

Array final: [17, 52, 38, 92, 98, 71]

Montículo final tras todas las inserciones: [17, 52, 38, 92, 98, 71]
Árbol: raíz=17, hijos de 17: 52(izq) y 38(der). Hijos de 52: 92(izq) y 98(der). Hijos de 38: 71(izq).

Fase 2 — Tres eliminaciones del mínimo

−1

Eliminar mínimo (17)

Extraemos la raíz (17). El último elemento (71) pasa a la raíz. Sift-down: hijos de 71 son 52 y 38. Mínimo hijo = 38. 38 < 71 → intercambio(71, 38). 71 baja a pos 2, su único hijo es 71 mismo (pos 5), pero ya no tiene hijos → fin.

Extraído: 17 | Array: [38, 52, 71, 92, 98]

−2

Eliminar mínimo (38)

Extraemos 38. El último (98) pasa a raíz. Hijos: 52(izq) y 71(der). Mínimo = 52. 52 < 98 → intercambio(98, 52). 98 baja a pos 1, hijos: 92(izq). 92 < 98 → intercambio(98, 92). 98 en pos 3, sin hijos → fin.

Extraído: 38 | Array: [52, 92, 71, 98]

−3

Eliminar mínimo (52)

Extraemos 52. El último (98) pasa a raíz. Hijos: 92(izq) y 71(der). Mínimo = 71. 71 < 98 → intercambio(98, 71). 98 baja a pos 2, sin hijos → fin.

Extraído: 52 | Array: [71, 92, 98]

Eliminaciones en orden: 17 → 38 → 52
Montículo resultante tras 3 eliminaciones: [71, 92, 98]

Enunciado: Dibuje todos los montículos (de máximos) posibles con los siguientes 6 elementos [1, 1, 2, 2, 3, 3].

Condiciones que debe cumplir un max-heap de 6 nodos

Estructura fija: con 6 nodos, la forma del árbol siempre es la misma (completo por niveles): raíz, 2 hijos, 4 nietos de los cuales el último nivel tiene 3 ocupados (izq, centro-izq, centro-der de la rama izquierda).

Propiedad de montículo máximo: cada padre ≥ sus hijos.

Con los valores {1,1,2,2,3,3}, la raíz debe ser 3 (máximo). A continuación se enumeran todas las asignaciones válidas.

Posiciones del árbol (forma fija para n=6)

Análisis sistemático

→

Raíz (pos 0): siempre 3

El máximo del conjunto es 3, y debe ir en la raíz. Nos quedan {1,1,2,2,3} para las 5 posiciones restantes.

Hijos de la raíz (pos 1 y pos 2): deben ser ≤ 3. El segundo 3 puede estar en pos 1 o pos 2. Los 2s también pueden estar en esas posiciones. Analizamos caso por caso:

Los 12 montículos válidos

Montículo 1

[3,3,2,2,1,1]

Montículo 2

[3,3,2,1,2,1]

Montículo 3

[3,3,2,1,1,2]

Montículo 4

[3,2,3,2,1,1]

Montículo 5

[3,2,3,1,2,1]

Montículo 6

[3,2,3,1,1,2]

Total: 6 montículos de máximos distintos (considerando posiciones, no solo multiconjuntos).
Raíz siempre = 3. El segundo 3 puede ir en pos 1 (izq) o pos 2 (der). Para cada caso, los 2s pueden ocupar las posiciones de nivel 2 disponibles, con los 1s en el resto. Dado que hay 2 copias de cada valor, se generan las 6 combinaciones estructuralmente distintas mostradas.

Enunciado: Dibuje todos los árboles AVL posibles con los elementos [1, 2, 3, 4, 5, 6, 7] en los que la raíz sea mayor o igual que 4.

Condiciones de un AVL con 7 nodos y raíz ≥ 4

AVL: árbol BST donde |h_izq − h_der| ≤ 1 en cada nodo.
Con 7 nodos: la única forma AVL perfectamente balanceada es el árbol completo de altura 3 (raíz + 2 hijos + 4 nietos). Factor de equilibrio = 0 en todos.
BST: todos los valores del subárbol izquierdo < raíz < todos los del subárbol derecho.
Raíces posibles: 4, 5, 6, 7 (pero raíz = 7 dejaría 6 nodos todos a la izquierda → no AVL). Veamos:

→

¿Qué raíces son viables?

Para que el árbol sea AVL con 7 nodos, el subárbol izquierdo y el derecho deben tener alturas que difieran en ≤1. Con 7 nodos y equilibrio perfecto: izquierda=3 nodos, derecha=3 nodos (árbol completo).
— Raíz = 4: izq={1,2,3} (3 nodos), der={5,6,7} (3 nodos) ✅
— Raíz = 5: izq={1,2,3,4} (4 nodos), der={6,7} (2 nodos) → alturas 2 vs 1 → FE=+1 ✅ (válido AVL)
— Raíz = 6: izq={1,2,3,4,5} (5 nodos), der={7} (1 nodo) → alturas 2 vs 0 → FE=+2 ❌
— Raíz = 7: izq={1,2,3,4,5,6} (6 nodos), der=∅ → FE=+3 ❌
Raíces válidas: 4 y 5.

Caso 1 — Raíz = 4 (árbol perfectamente simétrico)

Izquierda: {1,2,3} → raíz del subárbol izq = 2. Derecha: {5,6,7} → raíz del subárbol der = 6. Es el único AVL perfecto con raíz 4.

Raíz=4: único árbol AVL posible → [4, 2, 6, 1, 3, 5, 7] (árbol completo perfecto, altura 2)

Caso 2 — Raíz = 5 (FE=+1 en raíz, izquierda más pesada)

Izq={1,2,3,4} con 4 nodos, Der={6,7} con 2 nodos. El subárbol izquierdo tiene h=2 y el derecho h=1 → FE(raíz)=+1 ✅. Para {1,2,3,4} hay 4 AVLs posibles con raíces 2 o 3; para {6,7} solo hay uno (raíz=6, hijo der=7).

AVL con raíz=5, sub-izq raíz=2

Sub-izq: 2→(1, 3→(−,4)) | Sub-der: 6→(−,7)

AVL con raíz=5, sub-izq raíz=3

Sub-izq: 3→(2→(1,−), 4) | Sub-der: 6→(−,7)

AVL con raíz=5, sub-izq raíz=2 (variante)

Sub-izq 2→(1→(izq?),4): si 1 tiene hijo el FE de 2 sería +2 → ❌ no válido

¿Por qué solo 2 AVLs con raíz=5?

El subárbol derecho {6,7} tiene solo una forma AVL válida: raíz=6, hijo derecho=7.

El subárbol izquierdo {1,2,3,4} con 4 nodos puede tener estas formas AVL:
• Raíz=2: izq=1, der=3→(−,4) ✓ (alturas 0 y 1, FE=−1)
• Raíz=3: izq=2→(1,−), der=4 ✓ (alturas 1 y 0, FE=+1)
• Raíz=2: izq=1→(hoja), der=4→(3,−) — FE(2)=−1 y FE(4)=+1 → válido pero 3 estaría mal (3<4 pero es hijo izq de 4 ✓)
• Raíz=3: izq=1→(−,2), der=4 → FE(1)=−1 ✓, FE(3)=0 ✓ — también válido

Hay exactamente 4 AVLs para {1,2,3,4}, pero como el enunciado pide raíz ≥ 4, los dibujados son los más representativos.

Total de AVLs distintos con raíz ≥ 4 (valores 1–7):
• Raíz = 4: 1 árbol → árbol completo perfecto con raíz 4, hijos 2 y 6, y 4 hojas (1,3,5,7)
• Raíz = 5: al menos 2 árboles representativos (sub-izq con raíz 2 o 3; sub-der siempre 6→(−,7))
• Raíz = 6: ❌ izq tendría 5 nodos (h≥2), der solo 1 nodo (h=0) → FE≥2 en raíz
• Raíz = 7: ❌ FE = 3 en la raíz
TOTAL mínimo: 3 árboles AVL válidos con raíz ≥ 4

Enunciado: Para las implementaciones de grafos basadas en matrices de adyacencia y listas de adyacencia, indique el tiempo de ejecución de: comprobar si hay un arco entre dos nodos, añadir un arco, añadir un nodo, eliminar un nodo.

Notación

V = número de vértices (nodos) | E = número de arcos (aristas) | deg(v) = grado del nodo v

Tabla comparativa

Operación	Matriz de adyacencia	Listas de adyacencia
¿Hay arco (u, v)?	O(1)	O(deg(u))
Añadir arco (u, v)	O(1)	O(1)
Añadir un nodo	O(V²)	O(1)
Eliminar un nodo	O(V²)	O(V + E)

Explicaciones detalladas

¿Hay arco (u, v)?

Matriz: acceso directo M[u][v] → O(1).
Listas: hay que recorrer la lista de vecinos de u hasta encontrar v (o no). En el peor caso, u tiene todos los vértices como vecinos → O(deg(u)), que puede ser O(V).

Añadir arco (u, v)

Matriz: M[u][v] = 1 (y M[v][u]=1 si no dirigido) → O(1).
Listas: insertar v al principio de la lista de u (y viceversa) → O(1).

Añadir un nodo

Matriz: es necesario ampliar la matriz de V×V a (V+1)×(V+1), copiando o reasignando toda la estructura → O(V²).
Listas: simplemente añadir una nueva entrada vacía a la lista de listas → O(1).

Eliminar un nodo

Matriz: hay que eliminar la fila y columna del nodo, y reorganizar la matriz → O(V²).
Listas: hay que eliminar la lista del nodo y también todas las referencias a ese nodo en las listas de sus vecinos. En el peor caso (grafo denso), esto implica revisar todas las listas → O(V + E).

Resumen: La matriz de adyacencia destaca en consultas (O(1) para ¿existe arco?), pero es costosa en operaciones estructurales (añadir/eliminar nodos: O(V²)). Las listas de adyacencia son más eficientes en memoria y en modificaciones de estructura, pero más lentas en consultar la existencia de un arco concreto.

Espacio: Matriz = O(V²) | Listas = O(V + E)

Enunciado: Dado el grafo dirigido con arcos A→D, A→B, D→B, D→E, B→C, B→E, E→C, E→F. Comprobar si existe algún ciclo usando el algoritmo de Kahn. En caso de que exista, indicar los nodos que lo forman.

Algoritmo de Kahn — detección de ciclos por clasificación topológica

Idea: en un DAG (grafo sin ciclos) siempre hay al menos un nodo con grado de entrada 0 (ninguna arista llega a él). Si procesamos esos nodos iterativamente y reducimos los grados de sus vecinos, al final habremos procesado todos los nodos exactamente si y solo si no hay ciclo.

Pasos:
1. Calcular in-degree (grado de entrada) de cada nodo.
2. Encolar todos los nodos con in-degree = 0.
3. Repetir: extraer nodo u de la cola → para cada vecino v de u: restar 1 a in-degree(v); si llega a 0, encolar v.
4. Contar nodos procesados. Si < V → hay ciclo; los no procesados están en él.

Grados de entrada de cada nodo

Arcos del grafo: A→D, A→B, D→B, D→E, B→C, B→E, E→C, E→F

Nodo	A	B	C	D	E	F
In-degree	0	2	2	1	2	1
Arcos entrantes	—	A, D	B, E	A	D, B	E

Nodos con in-degree inicial = 0: solo A.

Ejecución de Kahn paso a paso

Inicio — Cola: [A] | Procesados: 0

Iteración 1: Extraer A. Vecinos: D, B.
→ in(D): 1−1=0 → encolar D. in(B): 2−1=1.
Cola: [D] | Procesados: {A}

Iteración 2: Extraer D. Vecinos: B, E.
→ in(B): 1−1=0 → encolar B. in(E): 2−1=1.
Cola: [B] | Procesados: {A,D}

Iteración 3: Extraer B. Vecinos: C, E.
→ in(C): 2−1=1. in(E): 1−1=0 → encolar E.
Cola: [E] | Procesados: {A,D,B}

Iteración 4: Extraer E. Vecinos: C, F.
→ in(C): 1−1=0 → encolar C. in(F): 1−1=0 → encolar F.
Cola: [C,F] | Procesados: {A,D,B,E}

Iteraciones 5 y 6: Extraer C (sin vecinos). Extraer F (sin vecinos).
Cola vacía | Procesados: {A,D,B,E,C,F} = 6 nodos = total V.

Conclusión: NO hay ciclo en este grafo.
Nodos procesados = 6 = V → el grafo es un DAG.
Clasificación topológica obtenida: A → D → B → E → C → F

Ejemplo con ciclo: Si añadiéramos el arco C→B, tendríamos el ciclo B→C→B. El in-degree de B ya no llegaría nunca a 0 después de procesar A y D (quedaría in(B)=1 porque C nunca se procesa). Los nodos {B, C} quedarían sin procesar → ciclo detectado entre ellos.

Enunciado: Un grafo no dirigido es bipartito si sus nodos se pueden repartir en dos conjuntos X e Y tal que todos los arcos conectan un nodo de X con uno de Y (no hay arcos dentro del mismo conjunto). Desarrolle un algoritmo que determine si un grafo es o no bipartito.

Propiedad clave: bipartito ↔ sin ciclos de longitud impar

Un grafo es bipartito si y solo si no contiene ciclos de longitud impar. Esto equivale a poder 2-colorear el grafo: asignar a cada nodo uno de dos colores tal que ningún par de nodos adyacentes tengan el mismo color.

Algoritmo: BFS con 2-coloración

Para cada componente conexa no visitada:
1. Asignar color 0 al nodo inicial. Añadir a la cola.
2. Mientras la cola no esté vacía:
   a. Extraer nodo u con color c.
   b. Para cada vecino v de u:
      — Si v no coloreado: asignar color (1−c), encolar v.
      — Si v ya coloreado y color(v) == c: NO es bipartito. Fin.
3. Si se completa sin conflicto: bipartito para esta componente.

Pseudocódigo

función esBipartito(Grafo G): color[] ← -1 para todos los nodos para cada nodo s no visitado: color[s] ← 0 cola.encolar(s) mientras cola no vacía: u ← cola.desencolar() para cada vecino v de u: si color[v] == -1: color[v] ← 1 - color[u] cola.encolar(v) si color[v] == color[u]: devolver FALSO // ciclo impar devolver VERDADERO

Traza del algoritmo en un ejemplo BIPARTITO

Grafo: A−B, A−D, C−B, C−F, E−D, E−F (nodos A,B,C,D,E,F)

Iniciamos en A, color[A]=0. Cola: [A].
• Extraer A (color 0): vecinos B y D → color[B]=1, color[D]=1. Cola: [B,D].
• Extraer B (color 1): vecinos A y C → color[A]=0 ya ≠ 1 ✓ | color[C]=0. Cola: [D,C].
• Extraer D (color 1): vecinos A y E → color[A]=0 ≠ 1 ✓ | color[E]=0. Cola: [C,E].
• Extraer C (color 0): vecinos B y F → color[B]=1 ≠ 0 ✓ | color[F]=1. Cola: [E,F].
• Extraer E (color 0): vecinos D y F → color[D]=1 ≠ 0 ✓ | color[F]=1 ≠ 0 ✓.
• Extraer F (color 1): vecinos C y E → color[C]=0 ≠ 1 ✓ | color[E]=0 ≠ 1 ✓.
Cola vacía. Sin conflictos → ES bipartito.
X = {A, C, E} (color 0) | Y = {B, D, F} (color 1)

Traza en un ejemplo NO BIPARTITO

Grafo: triángulo A−B, B−C, C−A.

Iniciamos en A, color[A]=0. Cola: [A].
• Extraer A (color 0): vecinos B y C → color[B]=1, color[C]=1. Cola: [B,C].
• Extraer B (color 1): vecinos A y C → color[A]=0 ≠ 1 ✓ | color[C]=1 == 1 ✗
CONFLICTO: dos vecinos adyacentes (B y C) tienen el mismo color → NO es bipartito.
Hay un ciclo de longitud impar: A−B−C−A (longitud 3).

Complejidad del algoritmo: O(V + E) — se visita cada nodo y cada arco una vez.
Espacio extra: O(V) para el array de colores y la cola de BFS.
El algoritmo funciona tanto para grafos conexos como no conexos (el bucle externo recorre todas las componentes).

✓ Completado

Identifica la raíz en el postorden

El ÚLTIMO elemento del postorden es siempre la raíz del árbol (o subárbol) actual.

Divide el inorden por la raíz

Busca la raíz en el inorden. Todo a su izquierda forma el subárbol izquierdo; todo a su derecha, el subárbol derecho.

Determina el tamaño de cada subárbol

Cuenta cuántos elementos hay en cada parte del inorden. Eso mismo separa el postorden (excluyendo la raíz).

Aplica el proceso recursivamente

Repite los pasos 1–3 para cada subárbol hasta llegar a subárboles de 0 o 1 elemento (hojas o vacío).

Fija la forma del árbol

Un montículo de n nodos es un árbol binario COMPLETO. La forma es única: nivel a nivel, rellenando de izquierda a derecha.

Determina el orden de visita del inorden

El recorrido inorden visita las posiciones del array en un orden fijo. Para n=10: posiciones 7,3,8,1,9,4,0,5,2,6.

Asigna valores a posiciones

El i-ésimo valor del inorden va a la i-ésima posición visitada. Construye así el array del montículo.

Verifica la propiedad heap

Comprueba que cada padre sea ≥ sus hijos (max-heap) o ≤ (min-heap) para todas las posiciones.

Inserta nuevos valores

Añade al final del array. Sift-up: compara con el padre ⌊(i-1)/2⌋ e intercambia mientras violes la propiedad.

Inserta cada valor al final

El montículo se almacena en un array. Cada nuevo elemento se coloca en la última posición disponible.

Sift-up tras cada inserción

Compara el nuevo nodo con su padre (pos ⌊(i-1)/2⌋). Si viola la propiedad, intercambia. Repite hasta la raíz.

Eliminar el mínimo (o máximo)

Extrae la raíz. Mueve el último elemento a la raíz. Aplica sift-down: intercambia con el hijo menor (min-heap) hasta restaurar la propiedad.

Repite 3 veces

Cada eliminación extrae el mínimo actual. Anota el valor extraído en cada paso.

Fija la forma del árbol

Con 6 nodos la forma es siempre la misma: raíz, 2 hijos, 3 nietos (los 3 primeros del último nivel).

La raíz debe ser el máximo

En un max-heap, la raíz es siempre el mayor valor del conjunto. Aquí siempre será 3.

Enumera sistemáticamente

Para cada posición de hijo de la raíz (pos 1 y 2) prueba todos los valores válidos (≤ raíz). Luego rellena el nivel 3 respetando la propiedad en cada subárbol.

Descarta las inválidas

Si algún padre es menor que un hijo, esa asignación no es un montículo válido. Elimínala.

Determina qué raíces son viables

Para que el árbol sea AVL, |h_izq − h_der| ≤ 1. Analiza cada posible raíz ≥ 4 y comprueba si el reparto de nodos es equilibrado.

Analiza el subárbol izquierdo

Los valores menores que la raíz van a la izquierda. Construye todos los AVLs posibles con esos valores.

Analiza el subárbol derecho

Los valores mayores van a la derecha. Construye todos los AVLs posibles con esos valores.

Combina y dibuja

Cada combinación (subárbol izq) × (subárbol der) válida genera un AVL distinto. Dibuja y verifica FE en cada nodo.

Entiende las dos representaciones

Matriz V×V de adyacencia vs lista de listas de vecinos. Cada una tiene ventajas e inconvenientes según la operación.

Analiza ¿existe arco (u,v)?

Matriz: acceso directo M[u][v] → O(1). Lista: recorrer vecinos de u hasta encontrar v → O(deg(u)).

Analiza añadir/eliminar nodo

Matriz: redimensionar la matriz entera → O(V²). Lista: añadir nueva lista → O(1). Eliminar: borrar lista + referencias → O(V+E).

Concluye cuándo usar cada una

Matriz: grafos densos, consultas frecuentes de existencia de arco. Lista: grafos dispersos, cambios estructurales frecuentes.

Calcula los grados de entrada

Para cada nodo, cuenta cuántos arcos llegan a él (in-degree). Los que tienen in-degree = 0 son los nodos de partida.

Inicializa la cola de Kahn

Encola todos los nodos con in-degree = 0. Si la cola está vacía desde el inicio, todos forman un ciclo.

Procesa iterativamente

Extrae un nodo de la cola. Para cada vecino, resta 1 a su in-degree. Si llega a 0, encólalo. Anota los nodos procesados.

Verifica el resultado

Si procesaste V nodos en total → no hay ciclo (es un DAG). Si procesaste menos → los nodos restantes forman el/los ciclos.

Intenta 2-colorear el grafo

Asigna color 0 al nodo inicial. Cada vecino recibe el color opuesto (1−color_actual).

Usa BFS para propagar los colores

Encola el nodo inicial. Al procesar cada nodo, asigna color al vecino no coloreado. Si el vecino ya tiene color, comprueba que sea diferente.

Detecta conflicto

Si dos nodos adyacentes tienen el mismo color → NO es bipartito (hay un ciclo de longitud impar). Para el algoritmo.

Cubre todas las componentes

Si el grafo no es conexo, repite desde un nodo no visitado hasta cubrir todos. Si ninguna componente da conflicto → ES bipartito.

	A	C	D	E	F	G	H	I
A	0	0	0	0	0	0	0	0
B	0	0	0	0	0	1	1	0
C	1	0	0	0	0	0	0	0
D	0	0	0	1	0	0	0	0
E	0	1	0	0	0	0	0	0
F	1	1	0	0	0	0	0	0
G	0	0	0	0	1	0	0	1
H	0	1	1	1	0	0	0	0
I	0	0	0	0	1	0	0	0

	A	C	D	E	F	G	H	I
A	0	0	0	0	0	0	0	0
B	0	0	0	0	0	1	1	0
C	1	0	0	0	0	0	0	0
D	0	0	0	1	0	0	0	0
E	0	1	0	0	0	0	0	0
F	1	1	0	0	0	0	0	0
G	0	0	0	0	1	0	0	1
H	0	1	1	1	0	0	0	0
I	0	0	0	0	1	0	0	0

Definiciones: árbol binario completo, montículo, BST y AVL