Comment représenter un graphique à l’aide d’une matrice de corrélation en Java ?

Afin de représenter un graphe en Java à l'aide d'une matrice d'association, il faut construire une structure de données contenant les relations entre les sommets et les arêtes. Une matrice d'association est un tableau bidimensionnel dans lequel les lignes et les colonnes représentent respectivement les sommets et les arêtes, et les entrées représentent les connexions entre eux. S'il y a "1" à la position (i, j), alors le sommet i coupe l'arête j. Bien que davantage de mémoire puisse être requise pour les graphes volumineux, cette approche permet des opérations graphiques efficaces telles que l'insertion ou la suppression d'arêtes. En créant cette structure de données en Java, les programmeurs peuvent créer et manipuler efficacement des structures graphiques pour résoudre de nombreux problèmes en informatique et dans des domaines connexes.

Matrice de corrélation

Dans la théorie des graphes, la relation entre les sommets et les arêtes d'un graphique est représentée mathématiquement par une matrice d'association. La matrice de corrélation est une matrice binaire bidimensionnelle dans laquelle les colonnes représentent les arêtes et les lignes représentent les sommets. L'entrée à la position (i, j) est « 1 » si le sommet i est adjacent à l'arête j, sinon elle est « 0 » ; Cette matrice représente efficacement la structure du graphique, facilitant ainsi la réalisation d'opérations telles que l'ajout et la suppression d'arêtes. Il s'agit d'un concept important en informatique et dans d'autres disciplines impliquant des réseaux complexes, car il fournit un outil clé pour analyser et résoudre des problèmes basés sur des graphes.

Méthode à utiliser

• Matrice de contiguïté

• Liste de contiguïté

• Liste Edge

Matrice de contiguïté

Une matrice de contiguïté est un tableau bidimensionnel utilisé pour représenter les connexions entre les sommets lors de la création de graphiques en Java. S'il existe une arête reliant le sommet i et le sommet j, vous pouvez la voir dans la cellule (i, j) de la matrice. Un "1" dans une cellule signifie qu'il y a un bord, tandis qu'un "0" signifie qu'il n'y a pas de bord. Cette matrice est souvent utilisée dans les graphiques denses car elle permet de parcourir et d'étudier rapidement le graphique. Cependant, en raison de sa forme carrée, il peut être gourmand en mémoire pour les grands tracés. Les programmeurs peuvent modéliser, analyser et manipuler efficacement des topologies de graphiques pour diverses applications en utilisant des matrices de contiguïté en Java.

Algorithme

Déterminer le nombre de sommets du graphique dans la première étape

• Construisez un tableau bidimensionnel (matrice) de [nombre de sommets] x [nombre de sommets].

• Initialisez la matrice en définissant toutes les entrées sur 0, ce qui signifie qu'il n'y a pas d'arêtes initialement.

• Dans le graphique, définissez la cellule de la matrice de corrélation de chaque arête (i, j) sur 1 pour représenter la connexion entre les sommets i et j.

• La symétrie matricielle est assurée dans les graphes non orientés puisque les arêtes (i,j) et (j,i) sont les mêmes.

• Comprend des routines pour tester la présence des arêtes, localiser les voisins des sommets et ajouter/supprimer des arêtes.

• Pour vérifier l'exactitude et la fonctionnalité de l'implémentation, veuillez la tester à l'aide de l'exemple de diagramme.

Exemple

#include <iostream>
#include <vector>

using namespace std;

class Graph {
private:
   int V;
   vector<vector<int>> adjMatrix;

public:
   Graph(int vertices) : V(vertices) {
      adjMatrix.resize(V, vector<int>(V, 0));
   }

   void addEdge(int u, int v) {
      adjMatrix[u][v] = 1;
      adjMatrix[v][u] = 1;
   }

   void printAdjMatrix() {
      for (int i = 0; i < V; ++i) {
         for (int j = 0; j < V; ++j) {
            cout << adjMatrix[i][j] << " ";
         }
         cout << endl;
      }
   }
};

int main() {
   int numVertices = 5;
   Graph graph(numVertices);

   graph.addEdge(0, 1);
   graph.addEdge(0, 4);
   graph.addEdge(1, 2);
   graph.addEdge(1, 3);
   graph.addEdge(1, 4);
   graph.addEdge(2, 3);
   graph.addEdge(3, 4);

   cout << "Adjacency Matrix:\n";
   graph.printAdjMatrix();

   return 0;
}

Sortie

Adjacency Matrix:
0 1 0 0 1 
1 0 1 1 1 
0 1 0 1 0 
0 1 1 0 1 
1 1 0 1 0 

Liste de contiguïté

La liste d'adjacence est une structure de données Java qui stocke efficacement les connexions. Lors de la représentation d'un graphique, une liste de contiguïté est une structure de données Java utilisée pour stocker efficacement les relations entre les sommets et leurs sommets adjacents. Chaque liste chaînée ou tableau qui compose cette structure correspond à un sommet et contient les voisins de ce sommet. Cette approche fonctionne bien pour les graphiques clairsemés car elle économise de la mémoire en ne conservant que les liens qui existent réellement. Les programmeurs peuvent effectuer rapidement des opérations de parcours de graphes, d'ajout de nœuds et de suppression en créant des listes de contiguïté en Java, ce qui en fait un choix populaire pour de nombreux algorithmes et applications liés aux graphes.

Algorithme

• Il est recommandé de stocker la liste de contiguïté dans une structure de données. Il peut s'agir d'un ensemble de listes chaînées ou d'une ArrayList, où chaque élément représente un sommet et stocke des informations sur les sommets adjacents.

• Démarrez une liste de contiguïté en ajoutant une liste vide ou ArrayList pour chaque sommet du graphique

• Pour ajouter des arêtes entre les sommets, vous devez fournir les méthodes correspondantes dans la classe graph. Ces techniques mettent à jour la liste de contiguïté en ajoutant les sommets nécessaires aux listes de contiguïté des autres.

• Ajoutez des méthodes de suppression d'arêtes ou de sommets pour modifier la liste de contiguïté si nécessaire.

• Utilisez des listes de contiguïté avec des techniques de parcours de graphique telles que la recherche en profondeur d'abord ou la recherche en largeur d'abord pour explorer rapidement tous les sommets du graphique.

• Pour résoudre de nombreux problèmes et techniques liés au réseau, utilisez des représentations graphiques et des listes de contiguïté dans les programmes Java.

Exemple

#include <iostream>
#include <vector>

using namespace std;

class Graph {
private:
   int numVertices;
   vector<vector<int>> adjList;

public:
   Graph(int vertices) : numVertices(vertices), adjList(vertices) {}

   void addEdge(int src, int dest) {
      adjList[src].push_back(dest);
      adjList[dest].push_back(src);
   }

   void printGraph() {
      for (int i = 0; i < numVertices; ++i) {
         cout << "Vertex " << i << " is connected to: ";
         for (int neighbor : adjList[i]) {
            cout << neighbor << " ";
         }
         cout << endl;
      }
   }
};

int main() {
   int numVertices = 5;
   Graph graph(numVertices);

   graph.addEdge(0, 1);
   graph.addEdge(0, 4);
   graph.addEdge(1, 2);
   graph.addEdge(1, 3);
   graph.addEdge(1, 4);
   graph.addEdge(2, 3);
   graph.addEdge(3, 4);

   graph.printGraph();

   return 0;
}

Sortie

Vertex 0 is connected to: 1 4 
Vertex 1 is connected to: 0 2 3 4 
Vertex 2 is connected to: 1 3 
Vertex 3 is connected to: 1 2 4 
Vertex 4 is connected to: 0 1 3 

Conclusion

Pour modéliser, analyser et manipuler efficacement les structures de réseau, Java fournit des fonctionnalités importantes en utilisant des matrices d'association ou des listes de contiguïté pour représenter des graphiques. Bien que plus gourmande en mémoire, la matrice de corrélation convient aux graphiques épais car elle simplifie l'ajout et la suppression d'arêtes. Les listes de contiguïté, en revanche, sont économes en mémoire et bien adaptées aux graphiques clairsemés, ce qui facilite la navigation dans le graphique et l'exécution d'autres opérations. En informatique et dans d’autres domaines, les deux représentations sont utilisées comme structures de données de base pour résoudre des problèmes liés aux graphiques. Les programmeurs peuvent utiliser ces stratégies pour créer des algorithmes et des applications fiables qui gèrent des réseaux complexes et des données interconnectées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!