Fixed sonar warnings

src/main/java/g0201_0300/s0295_find_median_from_data_stream/MedianFinder.java

@@ -15,7 +15,7 @@ public class MedianFinder {
 
     // initialize your data structure here.
     public MedianFinder() {
-        maxHeap = new PriorityQueue<>((a, b) -> (b - a));
+        maxHeap = new PriorityQueue<>((a, b) -> (Integer.compare(b, a)));
         minHeap = new PriorityQueue<>();
     }
 

src/main/java/g0301_0400/s0347_top_k_frequent_elements/Solution.java

@@ -12,7 +12,7 @@ public class Solution {
     public int[] topKFrequent(int[] nums, int k) {
         Arrays.sort(nums);
         // Min heap of <number, frequency>
-        Queue<int[]> queue = new PriorityQueue<>(k + 1, (a, b) -> (a[1] - b[1]));
+        Queue<int[]> queue = new PriorityQueue<>(k + 1, (a, b) -> (Integer.compare(a[1], b[1])));
         // Filter with min heap
         int j = 0;
         for (int i = 0; i <= nums.length; i++) {

src/main/java/g0401_0500/s0407_trapping_rain_water_ii/Solution.java

@@ -20,7 +20,7 @@ public Cell(int r, int c, int v) {
 
         @Override
         public int compareTo(Cell other) {
-            return value - other.value;
+            return Integer.compare(value, other.value);
         }
 
         @Override

src/main/java/g0501_0600/s0502_ipo/Solution.java

@@ -10,7 +10,8 @@ public class Solution {
     public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
         PriorityQueue<int[]> minCapital =
                 new PriorityQueue<>(Comparator.comparingInt((int[] a) -> a[1]));
-        PriorityQueue<int[]> maxProfit = new PriorityQueue<>((int[] a, int[] b) -> b[0] - a[0]);
+        PriorityQueue<int[]> maxProfit =
+                new PriorityQueue<>((int[] a, int[] b) -> Integer.compare(b[0], a[0]));
         for (int i = 0; i < profits.length; i++) {
             if (w >= capital[i]) {
                 maxProfit.offer(new int[] {profits[i], capital[i]});

src/main/java/g0601_0700/s0630_course_schedule_iii/Solution.java

@@ -9,13 +9,13 @@
 public class Solution {
     public int scheduleCourse(int[][] courses) {
         // Sort the courses based on their deadline date.
-        Arrays.sort(courses, (a, b) -> a[1] - b[1]);
+        Arrays.sort(courses, (a, b) -> Integer.compare(a[1], b[1]));
         // Only the duration is stored. We don't care which course
         // is the longest, we only care about the total courses can
         // be taken.
         // If the question wants the course ids to be returned.
         // Consider use a Pair<Duration, CourseId> int pair.
-        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> Integer.compare(b, a));
         // Total time consumed.
         int time = 0;
         // At the given time `course`, the overall "time limit" is

src/main/java/g0601_0700/s0632_smallest_range_covering_elements_from_k_lists/Solution.java

@@ -21,7 +21,7 @@ static class Triplet implements Comparable<Triplet> {
         }
 
         public int compareTo(Triplet obj) {
-            return this.value - obj.value;
+            return Integer.compare(this.value, obj.value);
         }
     }
 

src/main/java/g0601_0700/s0646_maximum_length_of_pair_chain/Solution.java

@@ -10,7 +10,7 @@ public int findLongestChain(int[][] pairs) {
         if (pairs.length == 1) {
             return 1;
         }
-        Arrays.sort(pairs, (a, b) -> a[1] - b[1]);
+        Arrays.sort(pairs, (a, b) -> Integer.compare(a[1], b[1]));
         int min = pairs[0][1];
         int max = 1;
         for (int i = 1; i < pairs.length; i++) {

src/main/java/g0601_0700/s0692_top_k_frequent_words/Solution.java

@@ -25,7 +25,7 @@ public List<String> topKFrequent(String[] words, int k) {
                 new TreeSet<>(
                         (e1, e2) -> {
                             if (e1.getValue().intValue() != e2.getValue().intValue()) {
-                                return e2.getValue() - e1.getValue();
+                                return Integer.compare(e2.getValue(), e1.getValue());
                             } else {
                                 return e1.getKey().compareToIgnoreCase(e2.getKey());
                             }

src/main/java/g0701_0800/s0729_my_calendar_i/MyCalendar.java

@@ -18,7 +18,7 @@ public Meeting(int start, int end) {
 
         @Override
         public int compareTo(Meeting anotherMeeting) {
-            return this.start - anotherMeeting.start;
+            return Integer.compare(this.start, anotherMeeting.start);
         }
     }
 

src/main/java/g0701_0800/s0736_parse_lisp_expression/Solution.java

@@ -15,6 +15,7 @@ static class Exp {
 
         public Exp(Exp from) {
             this.exps = new LinkedList<>();
+            this.op = null;
             this.parent = from;
         }
 

src/main/java/g0801_0900/s0871_minimum_number_of_refueling_stops/Solution.java

@@ -12,7 +12,7 @@ public int minRefuelStops(int target, int startFuel, int[][] stations) {
         } else if (stations == null || stations.length == 0) {
             return -1;
         }
-        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> b[1] - a[1]);
+        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> Integer.compare(b[1], a[1]));
         int start = 0;
         int end = stations.length;
         int currentFuel = startFuel;

src/main/java/g1001_1100/s1029_two_city_scheduling/Solution.java

@@ -6,7 +6,7 @@
 
 public class Solution {
     public int twoCitySchedCost(int[][] costs) {
-        Arrays.sort(costs, (a, b) -> (a[0] - a[1] - (b[0] - b[1])));
+        Arrays.sort(costs, (a, b) -> Long.compare((long) a[0] - a[1], (long) b[0] - b[1]));
         int cost = 0;
         for (int i = 0; i < costs.length; i++) {
             if (i < costs.length / 2) {

src/main/java/g1001_1100/s1046_last_stone_weight/Solution.java

@@ -7,7 +7,7 @@
 
 public class Solution {
     public int lastStoneWeight(int[] stones) {
-        PriorityQueue<Integer> heap = new PriorityQueue<>((a, b) -> b - a);
+        PriorityQueue<Integer> heap = new PriorityQueue<>((a, b) -> Integer.compare(b, a));
         for (int stone : stones) {
             heap.offer(stone);
         }

src/main/java/g1301_1400/s1366_rank_teams_by_votes/Solution.java

@@ -30,7 +30,7 @@ public String rankTeams(String[] votes) {
                 (o1, o2) -> {
                     for (int i = 0; i < 26; i++) {
                         if (o1.count[i] != o2.count[i]) {
-                            return o2.count[i] - o1.count[i];
+                            return Integer.compare(o2.count[i], o1.count[i]);
                         }
                     }
                     return o1.c - o2.c;

src/main/java/g1301_1400/s1383_maximum_performance_of_a_team/Solution.java

@@ -13,7 +13,8 @@ public int maxPerformance(int n, int[] speed, int[] efficiency, int k) {
             engineers[i][0] = speed[i];
             engineers[i][1] = efficiency[i];
         }
-        Arrays.sort(engineers, (engineer1, engineer2) -> engineer2[1] - engineer1[1]);
+        Arrays.sort(
+                engineers, (engineer1, engineer2) -> Integer.compare(engineer2[1], engineer1[1]));
         long speedSum = 0;
         long maximumPerformance = 0;
         PriorityQueue<Integer> minHeap = new PriorityQueue<>();

src/main/java/g1401_1500/s1439_find_the_kth_smallest_sum_of_a_matrix_with_sorted_rows/Solution.java

@@ -13,11 +13,11 @@ public int kthSmallest(int[][] mat, int k) {
                 new TreeSet<>(
                         (o1, o2) -> {
                             if (o1[0] != o2[0]) {
-                                return o1[0] - o2[0];
+                                return Integer.compare(o1[0], o2[0]);
                             } else {
                                 for (int i = 1; i < o1.length; i++) {
                                     if (o1[i] != o2[i]) {
-                                        return o1[i] - o2[i];
+                                        return Integer.compare(o1[i], o2[i]);
                                     }
                                 }
                                 return 0;

src/main/java/g1401_1500/s1453_maximum_number_of_darts_inside_of_a_circular_dartboard/Solution.java

@@ -19,10 +19,9 @@ private static class Angle implements Comparable<Angle> {
 
         @Override
         public int compareTo(Angle o) {
-            if (a > o.a) {
-                return 1;
-            } else if (a < o.a) {
-                return -1;
+            int angleComparison = Double.compare(a, o.a);
+            if (angleComparison != 0) {
+                return angleComparison;
             } else if (enter == o.enter) {
                 return 0;
             } else if (enter) {

src/main/java/g1501_1600/s1579_remove_max_number_of_edges_to_keep_graph_fully_traversable/Solution.java

@@ -6,7 +6,7 @@
 
 public class Solution {
     public int maxNumEdgesToRemove(int n, int[][] edges) {
-        Arrays.sort(edges, (a, b) -> (b[0] - a[0]));
+        Arrays.sort(edges, (a, b) -> (Integer.compare(b[0], a[0])));
         int[] alice = new int[n + 1];
         int[] rankAlice = new int[n + 1];
         int[] bob = new int[n + 1];

src/main/java/g1501_1600/s1584_min_cost_to_connect_all_points/Solution.java

@@ -86,7 +86,7 @@ public int getV() {
 
         @Override
         public int compare(Pair p1, Pair p2) {
-            return p1.dis - p2.dis;
+            return Integer.compare(p1.dis, p2.dis);
         }
     }
 }

src/main/java/g1601_1700/s1631_path_with_minimum_effort/Solution.java

@@ -19,7 +19,7 @@ private static class Pair implements Comparable<Pair> {
         }
 
         public int compareTo(Pair o) {
-            return this.diff - o.diff;
+            return Integer.compare(this.diff, o.diff);
         }
     }
 

src/main/java/g1601_1700/s1675_minimize_deviation_in_array/Solution.java

@@ -7,7 +7,7 @@
 
 public class Solution {
     public int minimumDeviation(int[] nums) {
-        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> Integer.compare(b, a));
         int min = Integer.MAX_VALUE;
         for (int num : nums) {
             if (num % 2 == 1) {

src/main/java/g1601_1700/s1686_stone_game_vi/Solution.java

@@ -19,7 +19,7 @@ private static class Pair implements Comparable<Pair> {
         }
 
         public int compareTo(Pair p) {
-            return p.sum - this.sum;
+            return Integer.compare(p.sum, this.sum);
         }
     }
 

src/main/java/g1601_1700/s1691_maximum_height_by_stacking_cuboids/Solution.java

@@ -13,11 +13,11 @@ public int maxHeight(int[][] arr) {
                 arr,
                 (a, b) -> {
                     if (a[0] != b[0]) {
-                        return a[0] - b[0];
+                        return Integer.compare(a[0], b[0]);
                     } else if (a[1] != b[1]) {
-                        return a[1] - b[1];
+                        return Integer.compare(a[1], b[1]);
                     }
-                    return a[2] - b[2];
+                    return Integer.compare(a[2], b[2]);
                 });
         int ans = 0;
         int[] dp = new int[arr.length];

src/main/java/g1701_1800/s1705_maximum_number_of_eaten_apples/Solution.java

@@ -7,7 +7,7 @@
 
 public class Solution {
     public int eatenApples(int[] apples, int[] days) {
-        PriorityQueue<int[]> minHeap = new PriorityQueue<>((a, b) -> a[0] - b[0]);
+        PriorityQueue<int[]> minHeap = new PriorityQueue<>((a, b) -> Integer.compare(a[0], b[0]));
         int eatenApples = 0;
         for (int i = 0; i < apples.length || !minHeap.isEmpty(); i++) {
             if (i < apples.length) {

src/main/java/g1701_1800/s1786_number_of_restricted_paths_from_first_to_last_node/Solution.java

@@ -19,7 +19,7 @@ private static class Pair implements Comparable<Pair> {
         }
 
         public int compareTo(Pair o) {
-            return this.cwt - o.cwt;
+            return Integer.compare(this.cwt, o.cwt);
         }
     }
 

src/main/java/g1801_1900/s1801_number_of_orders_in_the_backlog/Solution.java

@@ -19,7 +19,7 @@ private static class Order {
 
     public int getNumberOfBacklogOrders(int[][] orders) {
         PriorityQueue<Order> sell = new PriorityQueue<>(Comparator.comparingInt(a -> a.price));
-        PriorityQueue<Order> buy = new PriorityQueue<>((a, b) -> b.price - a.price);
+        PriorityQueue<Order> buy = new PriorityQueue<>((a, b) -> Integer.compare(b.price, a.price));
         for (int[] order : orders) {
             int price = order[0];
             int amount = order[1];

src/main/java/g1801_1900/s1834_single_threaded_cpu/Solution.java

@@ -19,9 +19,9 @@ public int[] getOrder(int[][] tasks1) {
                 new PriorityQueue<>(
                         (a, b) -> {
                             if (a[1] == b[1]) {
-                                return a[2] - b[2];
+                                return Integer.compare(a[2], b[2]);
                             } else {
-                                return a[1] - b[1];
+                                return Integer.compare(a[1], b[1]);
                             }
                         });
         int time = tasks[0][0];

src/main/java/g1801_1900/s1882_process_tasks_using_servers/Solution.java

@@ -13,7 +13,8 @@ public int[] assignTasks(int[] servers, int[] tasks) {
         for (int i = 0; i < servers.length; i++) {
             serverq.offer(i);
         }
-        PriorityQueue<int[]> activetaskq = new PriorityQueue<>((i1, i2) -> i1[1] - i2[1]);
+        PriorityQueue<int[]> activetaskq =
+                new PriorityQueue<>((i1, i2) -> Integer.compare(i1[1], i2[1]));
         int time = 0;
         int[] res = new int[tasks.length];
         for (int i = 0; i < tasks.length; i++) {

src/main/java/g2001_2100/s2002_maximum_product_of_the_length_of_two_palindromic_subsequences/Solution.java

@@ -22,7 +22,7 @@ public int maxProduct(String s) {
             recur(chars, new State(i, i, 0, mask), list, visited);
             recur(chars, new State(i, i + 1, 0, mask), list, visited);
         }
-        list.sort((a, b) -> b.cnt - a.cnt);
+        list.sort((a, b) -> Integer.compare(b.cnt, a.cnt));
         int res = 1;
         Set<Integer> explored = new HashSet<>();
         for (int i = 0; i < list.size() - 1; ++i) {

src/main/java/g2001_2100/s2054_two_best_non_overlapping_events/Solution.java

@@ -7,7 +7,7 @@
 
 public class Solution {
     public int maxTwoEvents(int[][] events) {
-        Arrays.sort(events, (a, b) -> a[0] - b[0]);
+        Arrays.sort(events, (a, b) -> Integer.compare(a[0], b[0]));
         int[] max = new int[events.length];
         for (int i = events.length - 1; i >= 0; i--) {
             if (i == events.length - 1) {

src/main/java/g2001_2100/s2092_find_all_people_with_secret/Solution.java

@@ -11,7 +11,7 @@
 
 public class Solution {
     public List<Integer> findAllPeople(int n, int[][] meetings, int firstPerson) {
-        Arrays.sort(meetings, ((a, b) -> a[2] - b[2]));
+        Arrays.sort(meetings, ((a, b) -> Integer.compare(a[2], b[2])));
         UF uf = new UF(n);
         // base
         uf.union(0, firstPerson);

src/main/java/g2001_2100/s2099_find_subsequence_of_length_k_with_the_largest_sum/Solution.java

@@ -15,7 +15,7 @@ public int[] maxSubsequence(int[] nums, int k) {
         // Loop from 0 to n-1 and add element in result if set contains those index
         // For ex. set has index 3,5,6 Just add those element. Order will be maintained
         // We are defining the min priority queue
-        PriorityQueue<int[]> q = new PriorityQueue<>((a, b) -> (a[0] - b[0]));
+        PriorityQueue<int[]> q = new PriorityQueue<>((a, b) -> (Integer.compare(a[0], b[0])));
         // Add element with index to priority queue
         for (int i = 0; i < nums.length; i++) {
             q.offer(new int[] {nums[i], i});

src/main/java/g2101_2200/s2102_sequentially_ordinal_rank_tracker/SORTracker.java

@@ -32,7 +32,7 @@ public SORTracker() {
                 new TreeSet<>(
                         (a, b) -> {
                             if (a.score != b.score) {
-                                return b.getScore() - a.getScore();
+                                return Integer.compare(b.getScore(), a.getScore());
                             } else {
                                 return a.getName().compareTo(b.getName());
                             }
@@ -42,7 +42,7 @@ public SORTracker() {
                 new TreeSet<>(
                         (a, b) -> {
                             if (a.score != b.score) {
-                                return b.getScore() - a.getScore();
+                                return Integer.compare(b.getScore(), a.getScore());
                             } else {
                                 return a.getName().compareTo(b.getName());
                             }

src/main/java/g2101_2200/s2136_earliest_possible_day_of_full_bloom/Solution.java

@@ -37,7 +37,7 @@ static class Seed implements Comparable<Seed> {
         }
 
         public int compareTo(Seed s) {
-            return this.growTime - s.growTime;
+            return Integer.compare(this.growTime, s.growTime);
         }
     }
 }

src/main/java/g2101_2200/s2146_k_highest_ranked_items_within_a_price_range/Solution.java

@@ -69,9 +69,9 @@ public List<List<Integer>> highestRankedKItems(
                     if (distDiff == 0) {
                         int priceDiff = a.price - b.price;
                         if (priceDiff == 0) {
-                            int rowDiff = a.row - b.row;
+                            int rowDiff = Integer.compare(a.row, b.row);
                             if (rowDiff == 0) {
-                                return a.col - b.col;
+                                return Integer.compare(a.col, b.col);
                             }
                             return rowDiff;
                         }

src/main/java/g2101_2200/s2163_minimum_difference_in_sums_after_removal_of_elements/Solution.java

@@ -9,7 +9,7 @@ public class Solution {
     public long minimumDifference(int[] nums) {
         int n = nums.length / 3;
         PriorityQueue<Integer> minHeap = new PriorityQueue<>();
-        PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);
+        PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> Integer.compare(b, a));
         long[] leftMemo = new long[nums.length];
         long[] rightMemo = new long[nums.length];
         long current = 0L;

src/main/java/g2101_2200/s2191_sort_the_jumbled_numbers/Solution.java

@@ -41,7 +41,7 @@ public int[] sortJumbled(int[] mapping, int[] nums) {
                     if (retval != 0) {
                         return retval;
                     }
-                    return a.index - b.index;
+                    return Integer.compare(a.index, b.index);
                 });
         int[] retval = new int[nums.length];
         for (int i = 0; i < nums.length; i++) {

src/main/java/g2201_2300/s2280_minimum_lines_to_represent_a_line_chart/Solution.java

@@ -10,7 +10,7 @@ public int minimumLines(int[][] stockPrices) {
         if (stockPrices.length == 1) {
             return 0;
         }
-        Arrays.sort(stockPrices, (a, b) -> a[0] - b[0]);
+        Arrays.sort(stockPrices, (a, b) -> Integer.compare(a[0], b[0]));
         // multiply with 1.0 to make it double and multiply with 100 for making it big so that
         // difference won't come out to be very less and after division it become 0.
         // failing for one of the case without multiply 100

src/main/java/g2201_2300/s2290_minimum_obstacle_removal_to_reach_corner/Solution.java

@@ -11,7 +11,7 @@ public int minimumObstacles(int[][] grid) {
         int n = grid.length;
         int m = grid[0].length;
         int[][] dirs = new int[][] {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
-        Queue<State> q = new PriorityQueue<>((a, b) -> a.removed - b.removed);
+        Queue<State> q = new PriorityQueue<>((a, b) -> Integer.compare(a.removed, b.removed));
         q.add(new State(0, 0, 0));
         boolean[][] visited = new boolean[n][m];
         visited[0][0] = true;