Fix DoubleHashingSort: Checkstyle compliance

- Declare RobustComparator as final class (line 42)
- Add curly braces to all single-line if statements (lines 79-126)
- Ensure all Checkstyle violations are resolved

Checkstyle fixes:
✓ Inner class RobustComparator declared as final
✓ All if statements now use curly braces {}
✓ Full compliance with Java coding standards

Previous fixes maintained:
✓ NullPointerException for null values
✓ Robust edge case handling (NaN, Infinity, empty strings)
✓ Clang-format compliance

Author: PauLopNun

src/main/java/com/thealgorithms/sorts/DoubleHashingSort.java

@@ -39,7 +39,7 @@ public <T extends Comparable<T>> T[] sort(T[] array) {
     /**
      * A robust comparator that handles edge cases for different data types
      */
-    private static class RobustComparator<T extends Comparable<T>> implements Comparator<T> {
+    private static final class RobustComparator<T extends Comparable<T>> implements Comparator<T> {
 
         @Override
         @SuppressWarnings("unchecked")
@@ -76,37 +76,37 @@ public int compare(T a, T b) {
 
         private int compareDoubles(Double a, Double b) {
             // Handle NaN: NaN should come last
-            if (Double.isNaN(a) && Double.isNaN(b)) return 0;
-            if (Double.isNaN(a)) return 1;
-            if (Double.isNaN(b)) return -1;
+            if (Double.isNaN(a) && Double.isNaN(b)) { return 0; }
+            if (Double.isNaN(a)) { return 1; }
+            if (Double.isNaN(b)) { return -1; }
 
             // Handle infinities
-            if (a.equals(Double.NEGATIVE_INFINITY) && b.equals(Double.NEGATIVE_INFINITY)) return 0;
-            if (a.equals(Double.NEGATIVE_INFINITY)) return -1;
-            if (b.equals(Double.NEGATIVE_INFINITY)) return 1;
+            if (a.equals(Double.NEGATIVE_INFINITY) && b.equals(Double.NEGATIVE_INFINITY)) { return 0; }
+            if (a.equals(Double.NEGATIVE_INFINITY)) { return -1; }
+            if (b.equals(Double.NEGATIVE_INFINITY)) { return 1; }
 
-            if (a.equals(Double.POSITIVE_INFINITY) && b.equals(Double.POSITIVE_INFINITY)) return 0;
-            if (a.equals(Double.POSITIVE_INFINITY)) return 1;
-            if (b.equals(Double.POSITIVE_INFINITY)) return -1;
+            if (a.equals(Double.POSITIVE_INFINITY) && b.equals(Double.POSITIVE_INFINITY)) { return 0; }
+            if (a.equals(Double.POSITIVE_INFINITY)) { return 1; }
+            if (b.equals(Double.POSITIVE_INFINITY)) { return -1; }
 
             // Normal comparison
             return Double.compare(a, b);
         }
 
         private int compareFloats(Float a, Float b) {
             // Handle NaN: NaN should come last
-            if (Float.isNaN(a) && Float.isNaN(b)) return 0;
-            if (Float.isNaN(a)) return 1;
-            if (Float.isNaN(b)) return -1;
+            if (Float.isNaN(a) && Float.isNaN(b)) { return 0; }
+            if (Float.isNaN(a)) { return 1; }
+            if (Float.isNaN(b)) { return -1; }
 
             // Handle infinities
-            if (a.equals(Float.NEGATIVE_INFINITY) && b.equals(Float.NEGATIVE_INFINITY)) return 0;
-            if (a.equals(Float.NEGATIVE_INFINITY)) return -1;
-            if (b.equals(Float.NEGATIVE_INFINITY)) return 1;
+            if (a.equals(Float.NEGATIVE_INFINITY) && b.equals(Float.NEGATIVE_INFINITY)) { return 0; }
+            if (a.equals(Float.NEGATIVE_INFINITY)) { return -1; }
+            if (b.equals(Float.NEGATIVE_INFINITY)) { return 1; }
 
-            if (a.equals(Float.POSITIVE_INFINITY) && b.equals(Float.POSITIVE_INFINITY)) return 0;
-            if (a.equals(Float.POSITIVE_INFINITY)) return 1;
-            if (b.equals(Float.POSITIVE_INFINITY)) return -1;
+            if (a.equals(Float.POSITIVE_INFINITY) && b.equals(Float.POSITIVE_INFINITY)) { return 0; }
+            if (a.equals(Float.POSITIVE_INFINITY)) { return 1; }
+            if (b.equals(Float.POSITIVE_INFINITY)) { return -1; }
 
             // Normal comparison
             return Float.compare(a, b);
@@ -121,9 +121,9 @@ private int compareNumbers(Number a, Number b) {
 
         private int compareStrings(String a, String b) {
             // Handle empty strings properly - they should come before non-empty strings
-            if (a.isEmpty() && b.isEmpty()) return 0;
-            if (a.isEmpty()) return -1;
-            if (b.isEmpty()) return 1;
+            if (a.isEmpty() && b.isEmpty()) { return 0; }
+            if (a.isEmpty()) { return -1; }
+            if (b.isEmpty()) { return 1; }
 
             // Normal string comparison
             return a.compareTo(b);