“AÑO DE LA UNIDAD LA PAZ Y EL

DESARROLLO”
UNIVERSIDAD TECNOLOGICA DE LOS
ANDES
INTEGRANTES  TEMA
Algoritmo de Kruskal
 Eliseo Pancorbo Diaz
 Vil Mijael Castro Muños  CURSO
Algoritmos y
 Dante Nayhua Huaman Programación ll
 Abraham Ernesto
Charalla Ramos
 HISTORIA
Joseph B. Kruskal investigador del Math
Center, que en 1956 descubrió su algoritmo
para la resolución del problema del Árbol
de coste total mínimo, también llamado
árbol recubridor euclídeo mínimo. Este
problema es un problema típico de
optimización combinatoria, que fue
considerado originalmente por Otakar
Boruvka (1926) mientras estudiaba la
necesidad de electrificación rural en el sur
de Moravia en Checoslovaquia(…)
 ALGORITMO DE KRUSKAL
 Es un algoritmo voraz, este nos permite encontrar el árbol de expansión
mínimo en un grafo conexo y ponderados.

 El objetivo del algoritmo de Kruskal es construir un árbol (subgrafo sin ciclos)

formado por arcos sucesivamente seleccionados de mínimo peso a partir de un
grafo con pesos en los arcos.
 Árbol de expansiÓn
Dado un grafo conexo, no dirigido G. Un árbol de expansión es un árbol
compuesto por todos los vértices y algunas (posiblemente todas) de las aristas de
G. Al ser creado un árbol no existirán ciclos, además debe existir una ruta entre
cada par de vértices.

Un grafo puede tener muchos arboles de expansión.

 ÁRBOL DE EXPANSIÓN MINIMA
Es un árbol compuesto por todos los vértices y cuya suma de sus aristas es la de
menor peso. Al ejemplo anterior le agregamos pesos a sus aristas y obtenemos los
arboles de expansiones siguientes:
Ejemplo y cÓdigo paso a paso
EJEMPLO 1. Determinar el árbol de mínima expansión para los siguientes grafos.
Utilizando el algoritmo de Kruskal:

SOLUCIÓN
CODIFICACIÓN Y EJECUCIÓN DEL PROGRAMA
 Algoritmo en Pseudocódigo padre = [i for i in range(self.V)]
class Grafo: rango = [0] * self.V
def __init__(self, vertices): while e < self.V - 1 and i < len(self.grafo):
self.V = vertices origen, destino, peso = self.grafo[i]
self.grafo = [] i += 1
def agregar_arista(self, origen, destino, peso): x = self.buscar(padre, origen)
self.grafo.append([origen, destino, peso]) y = self.buscar(padre, destino)
def buscar(self, padre, i):
if padre[i] == i: if x != y:
return i e += 1
return self.buscar(padre, padre[i]) resultado.append([origen, destino, peso])
def unir(self, padre, rango, x, y): self.unir(padre, rango, x, y)
x_raiz = self.buscar(padre, x) return resultado
y_raiz = self.buscar(padre, y)
g = Grafo(9)
if rango[x_raiz] < rango[y_raiz]: g.agregar_arista(1, 2, 3)
padre[x_raiz] = y_raiz g.agregar_arista(1, 3, 1)
elif rango[x_raiz] > rango[y_raiz]: g.agregar_arista(3, 2, 8)
padre[y_raiz] = x_raiz g.agregar_arista(2, 4, 7)
else: g.agregar_arista(2, 5, 5)
padre[y_raiz] = x_raiz g.agregar_arista(4, 7, 9)
rango[x_raiz] += 1 g.agregar_arista(4, 5, 6)
g.agregar_arista(5, 6, 1)
def kruskal(self): g.agregar_arista(5, 7, 2)
resultado = []
i=0 resultado = g.kruskal()
e=0
print("Aristas en el árbol de expansión mínima:")
self.grafo = sorted(self.grafo, key=lambda item: item[2]) for origen, destino, peso in resultado:
print(f"{origen} -- {destino} = {peso}")
CÓdigo

RESULTADO
Ejercicio 1
CÓdigo
Ejercicio 1
solución
EJEMPLO 2. Determinar el árbol de mínima expansión para los siguientes grafos.
Utilizando el algoritmo de Kruskal.

SOLUCIÓN
 CODIFICACIÓN Y EJECUCIÓN DEL PROGRAMA
 Algoritmo en Pseudocódigo Mientras e < longitud de vertices_indice - 1 y i < longitud de self.grafo:
Clase Grafo: u, v, w = self.grafo[i]
Método __init__(self, vertices): Incrementar i en 1
self.V = vertices x = self.buscar(padre, vertices_indice[u])
self.grafo = [] y = self.buscar(padre, vertices_indice[v])
Método agregar_arista(self, u, v, w):
Añadir [u, v, w] a self.grafo Si x no es igual a y:
Método buscar(self, padre, i): Incrementar e en 1
Si padre[i] es igual a i, retornar i Añadir [vertices_indice[u], vertices_indice[v], w] a resultado
Sino, retornar buscar(padre, padre[i]) Llamar a self.unir(padre, rango, x, y)
Método unir(self, padre, rango, x, y):
x_raiz = self.buscar(padre, x) Retornar resultado, vertices_indice
y_raiz = self.buscar(padre, y)
Si rango[x_raiz] < rango[y_raiz]:
padre[x_raiz] = y_raiz Crear objeto g de la Clase Grafo con 8 vértices
Sino, si rango[x_raiz] > rango[y_raiz]:
padre[y_raiz] = x_raiz Añadir aristas a g:
Sino: g.agregar_arista('a', 'b', 2)
padre[y_raiz] = x_raiz g.agregar_arista('a', 'c', 3)
rango[x_raiz] += 1 g.agregar_arista('b', 'd', 2)
Método kruskal(self): g.agregar_arista('c', 'd', 1)
resultado = [] g.agregar_arista('d', 'e', 2)
i=0 g.agregar_arista('d', 'f', 4)
e=0 g.agregar_arista('e', 'f', 1)
Ordenar self.grafo por el tercer elemento de cada lista (peso) g.agregar_arista('e', 'g', 2)
vertices_indice = {} g.agregar_arista('g', 'f', 2)
Para cada u, v, _ en self.grafo: g.agregar_arista('f', 'h', 1)
Si u no está en vertices_indice: g.agregar_arista('g', 'h', 3)
vertices_indice[u] = longitud de vertices_indice
Si v no está en vertices_indice: Aplicar algoritmo de Kruskal a g y almacenar el resultado en las variables resultado y vertices_indice
vertices_indice[v] = longitud de vertices_indice
padre = [i para i en rango(longitud de vertices_indice)] Imprimir "Aristas en el árbol de expansión mínima:"
rango = [0] * longitud de vertices_indice Para cada u, v, w en resultado:
Imprimir "{list(vertices_indice.keys())[u]} -- {list(vertices_indice.keys())[v]} = {w}"
 Ejercicio 2
Código
 Ejercicio 2
SOLUCIÓN
 Conclusiones
En resumen el algoritmo de Kruskal es un algoritmo de la teoría de grafos que se usa
para encontrar un árbol recubridor en un grafo conexo y poderado.

Es decir busca un subconjunto de aristas que, formando un árbol, incluyen todos los
vértices y donde el valor total de todas las aristas del árbol es el mínimo.
 Referencias bibliogrAficas
 RAMIREZ, C. (2016). Algoritmo de Kruskal. Estr.
https://jcrd0730.wixsite.com/estr/single-post/2016/05/25/algoritmo-de-kruskal-1

 Software para la construcción, edición y análisis de grafos. (2023). Webs.upv.es.

https://arodrigu.webs.upv.es/grafos/doku.php?id=algoritmo_kruskal

 ÁRBOL DE EXPANSIÓN MÍNIMA: ALGORITMO DE KRUSKAL. (2012). Algorithms and More.

https://jariasf.wordpress.com/2012/04/19/arbol-de-expansion-minima-algoritmo-de-kruskal/

 Algoritmo de Kruskal. AcademiaLab. (2020). Academia-Lab.com.

https://academia-lab.com/enciclopedia/algoritmo-de-kruskal/

‌ ALGORITMO DE KRUSKAL. (2023). Blogspot.com.

https://estructuradedatos2uninca.blogspot.com/p/a.html