Merge pull request #372 from LukasiJan-komo/translate-java-comments

Translate Java algorithm comments from Portuguese to English (resolves #182)

Author: kelvins

src/java/BinarySearch.java

@@ -1,24 +1,24 @@
-public class BuscaBinaria {
+public class BinarySearch {
 
-  public int posicao;
+  public int position;
 
-  BuscaBinaria(int[] array, int Objetivo) {
-    this.posicao = BinarySearch(Objetivo, array);
+  BinarySearch(int[] array, int target) {
+    this.position = binarySearch(target, array);
   }
 
-  public int GetResultado() {
-    return this.posicao;
+  public int getResult() {
+    return this.position;
   }
 
-  public int BinarySearch(int objetivo, int[] array) {
-    int comeco = 0;
-    int fim = array.length - 1;
+  public int binarySearch(int target, int[] array) {
+    int start = 0;
+    int end = array.length - 1;
 
-    while (comeco <= fim) {
-      int meio = comeco + (fim - comeco) / 2;
-      if (array[meio] == objetivo) return meio;
-      if (array[meio] < objetivo) comeco = meio + 1;
-      else fim = meio - 1;
+    while (start <= end) {
+      int middle = start + (end - start) / 2;
+      if (array[middle] == target) return middle;
+      if (array[middle] < target) start = middle + 1;
+      else end = middle - 1;
     }
     return -1;
   }

src/java/InsertionSort.java

@@ -2,35 +2,35 @@ public class InsertionSort {
 
   public static void main(String[] args) {
 
-    int vetor[] = {9, 0, 4, 2, 3, 8, 7, 1, 6, 5};
+    int[] array = {9, 0, 4, 2, 3, 8, 7, 1, 6, 5};
 
     System.out.println("Insertion Sort:");
-    System.out.println("Vetor não ordenado:");
-    mostraVetor(vetor);
+    System.out.println("Unsorted array:");
+    printArray(array);
 
-    vetor = insertionSort(vetor);
+    array = insertionSort(array);
 
-    System.out.println("Vetor ordenado:");
-    mostraVetor(vetor);
+    System.out.println("Sorted array:");
+    printArray(array);
   }
 
-  public static int[] insertionSort(int vetor[]) {
-    int chave, aux;
-    for (int i = 0; i < vetor.length; i++) {
-      chave = vetor[i];
+  public static int[] insertionSort(int[] array) {
+    int key, aux;
+    for (int i = 0; i < array.length; i++) {
+      key = array[i];
       aux = i - 1;
-      while (aux >= 0 && vetor[aux] > chave) {
-        vetor[aux + 1] = vetor[aux];
+      while (aux >= 0 && array[aux] > key) {
+        array[aux + 1] = array[aux];
         aux -= 1;
       }
-      vetor[aux + 1] = chave;
+      array[aux + 1] = key;
     }
-    return vetor;
+    return array;
   }
 
-  public static void mostraVetor(int vetor[]) {
-    for (int i = 0; i < vetor.length; i++) {
-      System.out.print(vetor[i] + ", ");
+  public static void printArray(int[] array) {
+    for (int i = 0; i < array.length; i++) {
+      System.out.print(array[i] + ", ");
     }
     System.out.println("");
   }

src/java/MergeSort.java

@@ -1,41 +1,41 @@
 class MergeSort {
-  void merge(int vetor[], int inicio, int meio, int fim) {
-    int n1 = meio - inicio + 1;
-    int n2 = fim - meio;
-    int Inicial[] = new int[n1];
-    int Final[] = new int[n2];
-    for (int i = 0; i < n1; ++i) Inicial[i] = vetor[inicio + i];
-    for (int j = 0; j < n2; ++j) Final[j] = vetor[meio + 1 + j];
+  void merge(int array[], int start, int middle, int end) {
+    int n1 = middle - start + 1;
+    int n2 = end - middle;
+    int Left[] = new int[n1];
+    int Right[] = new int[n2];
+    for (int i = 0; i < n1; ++i) Left[i] = array[start + i];
+    for (int j = 0; j < n2; ++j) Right[j] = array[middle + 1 + j];
     int i = 0, j = 0;
-    int k = inicio;
+    int k = start;
     while (i < n1 && j < n2) {
-      if (Inicial[i] <= Final[j]) {
-        vetor[k] = Inicial[i];
+      if (Left[i] <= Right[j]) {
+        array[k] = Left[i];
         i++;
       } else {
-        vetor[k] = Final[j];
+        array[k] = Right[j];
         j++;
       }
       k++;
     }
     while (i < n1) {
-      vetor[k] = Inicial[i];
+      array[k] = Left[i];
       i++;
       k++;
     }
     while (j < n2) {
-      vetor[k] = Final[j];
+      array[k] = Right[j];
       j++;
       k++;
     }
   }
 
-  void sort(int vetor[], int inicio, int fim) {
-    if (inicio < fim) {
-      int meio = (inicio + fim) / 2;
-      sort(vetor, inicio, meio);
-      sort(vetor, meio + 1, fim);
-      merge(vetor, inicio, meio, fim);
+  void sort(int array[], int start, int end) {
+    if (start < end) {
+      int middle = (start + end) / 2;
+      sort(array, start, middle);
+      sort(array, middle + 1, end);
+      merge(array, start, middle, end);
     }
   }
 }