renamed method variables and reformatted code.

Author: CasualProgrammer25

src/main/java/com/thealgorithms/strings/SuffixArray.java

@@ -18,49 +18,46 @@ private SuffixArray() {
     public static int[] buildSuffixArray(String text) {
         int n = text.length();
         Integer[] suffixArray = new Integer[n];
-        int[] rank = new int[n];
-        int[] tempRank = new int[n];
+        int[] currentRank = new int[n];
+        int[] nextRank = new int[n];
 
         // Initial ranking based on characters
         for (int i = 0; i < n; i++) {
             suffixArray[i] = i;
-            rank[i] = text.charAt(i);
+            currentRank[i] = text.charAt(i);
         }
 
-        for (int k = 1; k < n; k *= 2) {
-            final int step = k;
-
-            sortSuffixArray(suffixArray, rank, step, n);
+        for (int prefixLength = 1; prefixLength < n; prefixLength *= 2) {
+            sortSuffixArray(suffixArray, currentRank, prefixLength, n);
 
             // Re-rank
-            tempRank[suffixArray[0]] = 0;
+            nextRank[suffixArray[0]] = 0;
             for (int i = 1; i < n; i++) {
-                int prev = suffixArray[i - 1];
-                int curr = suffixArray[i];
-                boolean sameRank = rank[prev] == rank[curr] && ((prev + step < n ? rank[prev + step] : -1) == (curr + step < n ? rank[curr + step] : -1));
-                tempRank[curr] = sameRank ? tempRank[prev] : tempRank[prev] + 1;
+                int previousIndex = suffixArray[i - 1];
+                int currentIndex = suffixArray[i];
+                boolean sameRank = currentRank[previousIndex] == currentRank[currentIndex] && ((previousIndex + prefixLength < n ? currentRank[previousIndex + prefixLength] : -1) == (currentIndex + prefixLength < n ? currentRank[currentIndex + prefixLength] : -1));
+                nextRank[currentIndex] = sameRank ? nextRank[previousIndex] : nextRank[previousIndex] + 1;
             }
 
-            System.arraycopy(tempRank, 0, rank, 0, n);
+            System.arraycopy(nextRank, 0, currentRank, 0, n);
 
-            if (rank[suffixArray[n - 1]] == n - 1) {
+            if (currentRank[suffixArray[n - 1]] == n - 1) {
                 break;
             }
         }
         return Arrays.stream(suffixArray).mapToInt(Integer::intValue).toArray();
     }
 
-    private static Integer[] sortSuffixArray(Integer[] suffixArray, int[] rank, int step, int n) {
-        // Comparator: first by rank, then by rank + step
-        Arrays.sort(suffixArray, (a, b) -> {
-            if (rank[a] != rank[b]) {
-                return Integer.compare(rank[a], rank[b]);
+    private static void sortSuffixArray(Integer[] suffixArray, int[] currentRank, int comparisonLength, int n) {
+        // Comparator: first by rank, then by rank + comparisonLength
+        Arrays.sort(suffixArray, (indexA, indexB) -> {
+            if (currentRank[indexA] != currentRank[indexB]) {
+                return Integer.compare(currentRank[indexA], currentRank[indexB]);
             }
-            int ra = (a + step < n) ? rank[a + step] : -1;
-            int rb = (b + step < n) ? rank[b + step] : -1;
-            return Integer.compare(ra, rb);
+            int rankAtOffsetA = (indexA + comparisonLength < n) ? currentRank[indexA + comparisonLength] : -1;
+            int rankAtOffsetB = (indexB + comparisonLength < n) ? currentRank[indexB + comparisonLength] : -1;
+            return Integer.compare(rankAtOffsetA, rankAtOffsetB);
 
-            });
-        return suffixArray;
+        });
     }
 }