Translated Portuguese comments and added English comments alongside in Dijkstra.java

Author: Crade-IN

src/java/Dijkstra.java

@@ -1,20 +1,29 @@
-// Algoritimo de Dijkstra
+// Algoritimo de Dijkstra (Dijkstra's Algorithm)
 // Anderson Carneiro da Silva
 // https://github.com/AndersonSheep
 
-// Baseado no método do GeekforGeeks
-// Um programa Java para o algoritmo de caminho mais curto de fonte única de Dijkstra.
-// O programa é para representação da matriz de adjacência do grafo
+// Baseado no método do GeekforGeeks 
+// Um programa Java para o algoritmo de caminho mais curto de fonte única de Dijkstra. 
+// O programa é para representação da matriz de adjacência do grafo 
+
+/* Based on the GeekforGeeks method
+   A Java program for Dijkstra's single-source shortest path algorithm.
+   The program is for the representation of the graph's adjacency matrix */
+
 import java.io.*;
 import java.util.*;
 
 class ShortestPath {
   // Uma função de utilidade para encontrar o vértice com valor mínimo de distância,
   // do conjunto de vértices ainda não incluídos na árvore do caminho mais curto
+  
+  /* A utility function to find the vertex with the minimum distance value,
+     from the set of vertices not yet included in the shortest path tree */
   static final int V = 9;
 
   int minDistance(int dist[], Boolean sptSet[]) {
     // Iniciando um valor minimo
+    // Initializing a minimum value
     int min = Integer.MAX_VALUE, min_index = -1;
 
     for (int v = 0; v < V; v++) {
@@ -28,6 +37,7 @@ int minDistance(int dist[], Boolean sptSet[]) {
   }
 
   // Uma função de utilidade para imprimir a matriz de distância construída
+  // A utility function to print the constructed distance matrix
   void printSolution(int dist[]) {
     System.out.println("Vertex \t\t Distance from Source");
     for (int i = 0; i < V; i++) {
@@ -37,38 +47,57 @@ void printSolution(int dist[]) {
 
   // Função que implementa o caminho mais curto da fonte única de Dijkstra
   // algoritmo para um grafo representado usando matriz de adjacência
+
+  /* Function that implements Dijkstra's single-source shortest path algorithm 
+     for a graph represented using an adjacency matrix */
   void dijkstra(int graph[][], int src) {
     // A matriz de saída. dist [i] irá manter a menor distância de src a i
+    // The output array. dist[i] will hold the shortest distance from src to i
     int dist[] = new int[V];
 
     // sptSet [i] será verdadeiro se o vértice i for incluído no mais curto
     // árvore do caminho ou distância mais curta de src para i é finalizada
+
+    /* sptSet[i] will be true if vertex i is included in the shortest
+       path tree or the shortest distance from src to i is finalized */
     Boolean sptSet[] = new Boolean[V];
 
     // Inicializa todas as distâncias como INFINITE e stpSet [] como falso
+    // Initialize all distances as INFINITE and sptSet[] as false
     for (int i = 0; i < V; i++) {
       dist[i] = Integer.MAX_VALUE;
       sptSet[i] = false;
     }
 
     // A distância do vértice de origem é sempre 0
+    // The distance of the source vertex is always 0
     dist[src] = 0;
 
     // Encontre o caminho mais curto para todos os vértices
+    // Find the shortest path for all vertices
     for (int count = 0; count < V - 1; count++) {
       // Escolha o vértice de distância mínima do conjunto de vértices
       // ainda não processado. vc é sempre igual a src na primeira iteração.
+
+      /* Pick the vertex with the minimum distance from the set of vertices
+         not yet processed. u is always equal to src in the first iteration. */
       int u = minDistance(dist, sptSet);
 
       // Marque o vértice escolhido como processado
+      // Mark the chosen vertex as processed
       sptSet[u] = true;
 
       // Atualize o valor dist dos vértices adjacentes do vértice escolhido.
+      // Update the value dist for the adjacent vertices of the chosen vertex.
       for (int v = 0; v < V; v++)
 
         // Atualize dist [v] apenas se não estiver em sptSet, há um
         // borda de u a v, e peso total do caminho de src a
         // v a u é menor que o valor atual de dist [v]
+        
+        /* Update dist[v] only if it's not in sptSet, there is an edge from u to v,
+           and the total weight of the path from src to v through u is less than the
+           current value of dist[v] */
         if (!sptSet[v]
             && graph[u][v] != 0
             && dist[u] != Integer.MAX_VALUE
@@ -78,11 +107,13 @@ void dijkstra(int graph[][], int src) {
     }
 
     // Imprime a matriz de distância construída
+    // Print the constructed distance matrix
     printSolution(dist);
   }
 
   public static void main(String[] args) {
     // Vamos criar o gráfico de exemplo discutido acima
+    //Let's create the example graph discussed above
     int graph[][] =
         new int[][] {
           {0, 4, 0, 0, 0, 0, 0, 8, 0},