Comprendre l'algorithme de Kruskal

    Dans ce didacticiel, vous apprendrez comment fonctionne l'algorithme de Kruskal. De plus, vous trouverez des exemples en langage C.
    L'algorithme de Kruskal est un algorithme d'arbre couvrant minimum qui prend un graphique en entrée et trouve un sous-ensemble des arêtes du graphique. Le sous-ensemble

• Former un arbre avec chaque sommet
• Possède la plus petite somme de poids parmi tous les arbres pouvant être formés à partir du graphique

Comment fonctionne l'algorithme de Kruskal

    Il appartient à une classe d'algorithmes appelés algorithmes gloutons. Cet algorithme espère trouver l'optimum global en recherchant l'optimum local.
    Nous commençons par la carre avec le poids le plus faible et continuons à ajouter des arêtes jusqu'à ce que nous atteignions l'objectif.
    Les étapes pour implémenter l'algorithme de Kruskal sont les suivantes:

1. Trier tous les bords par poids de faible à élevé
2. Prenez le bord avec le plus petit poids et ajoutez-le à l'arbre couvrant. Si l'ajout d'une arête provoque une boucle, cette arête n'est pas utilisée.
3. Continuez à ajouter des arêtes jusqu'à ce que tous les sommets soient atteints.

Exemple d'algorithme de Kruskal

    À partir du graphique pondéré,

    sélectionnez l'arête avec le poids le plus petit. S'il y a plusieurs arêtes,

    sélectionnez l'arête la plus courte suivante et ajoutez-la.

    Sélectionnez l' arête la plus courte suivante qui ne crée pas de boucle et ajoutez-la. Sélectionnez l' arête la plus courte suivante qui ne crée pas de boucle et ne l'ajoute

    pas. Ajoutez-la et

    répétez les étapes ci-dessus jusqu'à ce qu'un Spanning Tree soit généré

Pseudo-code de l'algorithme de Kruskal

    Tout algorithme d'arbre couvrant minimum tourne autour de la question de savoir si l'ajout d'arêtes crée une boucle.
    La méthode la plus courante est un algorithme appelé Union-Find. L'algorithme Union-Find divise les sommets en clusters et vérifie si les deux sommets appartiennent au même cluster, évaluant ainsi si l'ajout d'une arête crée une boucle.

KRUSKAL(G):
A = ∅
For each vertex v ∈ G.V:
    MAKE-SET(v)
For each edge (u, v) ∈ G.E ordered by increasing order by weight(u, v):
    if FIND-SET(u) ≠ FIND-SET(v):       
    A = A ∪ {
    
    (u, v)}
    UNION(u, v)
return A

Exemple C

// Kruskal's algorithm in C

#include <stdio.h>

#define MAX 30

typedef struct edge {
    
    
  int u, v, w;
} edge;

typedef struct edge_list {
    
    
  edge data[MAX];
  int n;
} edge_list;

edge_list elist;

int Graph[MAX][MAX], n;
edge_list spanlist;

void kruskalAlgo();
int find(int belongs[], int vertexno);
void applyUnion(int belongs[], int c1, int c2);
void sort();
void print();

// Applying Krushkal Algo
void kruskalAlgo() {
    
    
  int belongs[MAX], i, j, cno1, cno2;
  elist.n = 0;

  for (i = 1; i < n; i++)
    for (j = 0; j < i; j++) {
    
    
      if (Graph[i][j] != 0) {
    
    
        elist.data[elist.n].u = i;
        elist.data[elist.n].v = j;
        elist.data[elist.n].w = Graph[i][j];
        elist.n++;
      }
    }

  sort();

  for (i = 0; i < n; i++)
    belongs[i] = i;

  spanlist.n = 0;

  for (i = 0; i < elist.n; i++) {
    
    
    cno1 = find(belongs, elist.data[i].u);
    cno2 = find(belongs, elist.data[i].v);

    if (cno1 != cno2) {
    
    
      spanlist.data[spanlist.n] = elist.data[i];
      spanlist.n = spanlist.n + 1;
      applyUnion(belongs, cno1, cno2);
    }
  }
}

int find(int belongs[], int vertexno) {
    
    
  return (belongs[vertexno]);
}

void applyUnion(int belongs[], int c1, int c2) {
    
    
  int i;

  for (i = 0; i < n; i++)
    if (belongs[i] == c2)
      belongs[i] = c1;
}

// Sorting algo
void sort() {
    
    
  int i, j;
  edge temp;

  for (i = 1; i < elist.n; i++)
    for (j = 0; j < elist.n - 1; j++)
      if (elist.data[j].w > elist.data[j + 1].w) {
    
    
        temp = elist.data[j];
        elist.data[j] = elist.data[j + 1];
        elist.data[j + 1] = temp;
      }
}

// Printing the result
void print() {
    
    
  int i, cost = 0;

  for (i = 0; i < spanlist.n; i++) {
    
    
    printf("\n%d - %d : %d", spanlist.data[i].u, spanlist.data[i].v, spanlist.data[i].w);
    cost = cost + spanlist.data[i].w;
  }

  printf("\nSpanning tree cost: %d", cost);
}

int main() {
    
    
  int i, j, total_cost;

  n = 6;

  Graph[0][0] = 0;
  Graph[0][1] = 4;
  Graph[0][2] = 4;
  Graph[0][3] = 0;
  Graph[0][4] = 0;
  Graph[0][5] = 0;
  Graph[0][6] = 0;

  Graph[1][0] = 4;
  Graph[1][1] = 0;
  Graph[1][2] = 2;
  Graph[1][3] = 0;
  Graph[1][4] = 0;
  Graph[1][5] = 0;
  Graph[1][6] = 0;

  Graph[2][0] = 4;
  Graph[2][1] = 2;
  Graph[2][2] = 0;
  Graph[2][3] = 3;
  Graph[2][4] = 4;
  Graph[2][5] = 0;
  Graph[2][6] = 0;

  Graph[3][0] = 0;
  Graph[3][1] = 0;
  Graph[3][2] = 3;
  Graph[3][3] = 0;
  Graph[3][4] = 3;
  Graph[3][5] = 0;
  Graph[3][6] = 0;

  Graph[4][0] = 0;
  Graph[4][1] = 0;
  Graph[4][2] = 4;
  Graph[4][3] = 3;
  Graph[4][4] = 0;
  Graph[4][5] = 0;
  Graph[4][6] = 0;

  Graph[5][0] = 0;
  Graph[5][1] = 0;
  Graph[5][2] = 2;
  Graph[5][3] = 0;
  Graph[5][4] = 3;
  Graph[5][5] = 0;
  Graph[5][6] = 0;

  kruskalAlgo();
  print();
}

Algorithme de Kruskal vs algorithme Prim

    L'algorithme de Prim est un autre algorithme d'arbre couvrant minimum populaire, qui utilise une logique différente pour trouver le MST (arbre couvrant minimum) du graphique. L'algorithme de Prim ne part pas d'une arête, mais d'un sommet, et continue d'ajouter des arêtes avec le plus petit poids qui ne sont pas dans l'arbre tant que tous les sommets ne sont pas couverts.

La complexité de l'algorithme de Kruskal

    La complexité temporelle de l'algorithme de Kruskal est: O (E log E).

Application de l'algorithme de Kruskal

• Disposer le câblage électrique
• Pour réseau informatique (connexion LAN)

Documents de référence

[1] Parewa Labs Pvt. Algorithme de Kruskal [EB / OL] .https: //www.programiz.com/dsa/kruskal-algorithm,2020-01-01.