Fixed review warnings.

Author: javadev

src/main/java/g0201_0300/s0224_basic_calculator/Solution.java

@@ -1,16 +1,14 @@
 package g0201_0300.s0224_basic_calculator;
 
 public class Solution {
-    int i = 0;
+    private int i = 0;
 
     public int calculate(String s) {
         char[] ca = s.toCharArray();
-
         return helper(ca);
     }
 
-    public int helper(char[] ca) {
-
+    private int helper(char[] ca) {
         int num = 0;
         int prenum = 0;
         boolean isPlus = true;

src/main/java/g0201_0300/s0225_implement_stack_using_queues/MyStack.java

@@ -4,24 +4,24 @@
 import java.util.Queue;
 
 public class MyStack {
-    Queue<Integer> queueOne;
-    Queue<Integer> queueTwo;
-    int top;
+    private Queue<Integer> queueOne;
+    private Queue<Integer> queueTwo;
+    private int top;
 
-    /** Initialize your data structure here. */
+    // Initialize your data structure here.
     public MyStack() {
         queueOne = new LinkedList<>();
         queueTwo = new LinkedList<>();
         top = 0;
     }
 
-    /** Push element x onto stack. */
+    // Push element x onto stack.
     public void push(int x) {
         queueOne.add(x);
         top = x;
     }
 
-    /** Removes the element on top of the stack and returns that element. */
+    // Removes the element on top of the stack and returns that element.
     public int pop() {
         while (queueOne.size() > 1) {
             int val = queueOne.remove();
@@ -32,16 +32,15 @@ public int pop() {
         int popValue = queueOne.remove();
         queueOne.addAll(queueTwo);
         queueTwo.clear();
-
         return popValue;
     }
 
-    /** Get the top element. */
+    // Get the top element.
     public int top() {
         return top;
     }
 
-    /** Returns whether the stack is empty. */
+    // Returns whether the stack is empty.
     public boolean empty() {
         return queueOne.isEmpty();
     }

src/main/java/g0201_0300/s0225_implement_stack_using_queues/readme.md

@@ -22,7 +22,14 @@ Implement the `MyStack` class:
 
 **Output:** \[null, null, null, 2, 2, false\]
 
-**Explanation:** MyStack myStack = new MyStack(); myStack.push(1); myStack.push(2); myStack.top(); // return 2 myStack.pop(); // return 2 myStack.empty(); // return False 
+**Explanation:**
+
+    MyStack myStack = new MyStack();
+    myStack.push(1);
+    myStack.push(2);
+    myStack.top(); // return 2
+    myStack.pop(); // return 2
+    myStack.empty(); // return False 
 
 **Constraints:**
 

src/main/java/g0201_0300/s0228_summary_ranges/Solution.java

@@ -9,10 +9,12 @@ public List<String> summaryRanges(int[] nums) {
         if (nums.length == 0) {
             return ranges;
         }
-        int n = nums.length; // size of array
-        int a = nums[0]; // start of range
-        int b = a; // end of range
-
+        // size of array
+        int n = nums.length;
+        // start of range
+        int a = nums[0];
+        // end of range
+        int b = a;
         StringBuilder strB = new StringBuilder();
         for (int i = 1; i < n; i++) {
             // we need to make a decision if the next element
@@ -26,19 +28,18 @@ public List<String> summaryRanges(int[] nums) {
                 if (a != b) {
                     strB.append("->").append(b);
                 }
-
                 ranges.add(strB.toString());
                 // since nums[i] is not accounted for by our range a->b
                 // because nums[i] is not b+1, we need to set a and b
                 // to this new range start point of bigger than b+1
                 // maybe it is b+2? b+3? b+4? all we know is it is not b+1
                 a = nums[i];
                 b = a;
-
                 // Reset string builder
                 strB.setLength(0);
             } else {
-                b++; // if the next element expands our range we do so
+                // if the next element expands our range we do so
+                b++;
             }
         }
         // the only range that is not accounted for at this point is the last range
@@ -48,7 +49,6 @@ public List<String> summaryRanges(int[] nums) {
             strB.append("->").append(b);
         }
         ranges.add(strB.toString());
-
         return ranges;
     }
 }

src/main/java/g0201_0300/s0232_implement_queue_using_stacks/MyQueue.java

@@ -4,39 +4,39 @@
 import java.util.Deque;
 
 public class MyQueue {
-    Deque<Integer> left;
-    Deque<Integer> right;
-    /** Initialize your data structure here. */
+    private Deque<Integer> left;
+    private Deque<Integer> right;
+    // Initialize your data structure here.
     public MyQueue() {
         left = new ArrayDeque<>();
         right = new ArrayDeque<>();
     }
 
-    /** Push element x to the back of queue. */
+    // Push element x to the back of queue.
     public void push(int x) {
         while (!right.isEmpty()) {
             left.add(right.pop());
         }
         left.add(x);
     }
 
-    /** Removes the element from in front of queue and returns that element. */
+    // Removes the element from in front of queue and returns that element.
     public int pop() {
         while (!left.isEmpty()) {
             right.add(left.pop());
         }
         return right.pop();
     }
 
-    /** Get the front element. */
+    // Get the front element.
     public int peek() {
         while (!left.isEmpty()) {
             right.add(left.pop());
         }
         return right.peek();
     }
 
-    /** Returns whether the queue is empty. */
+    // Returns whether the queue is empty.
     public boolean empty() {
         return right.isEmpty() && left.isEmpty();
     }

src/main/java/g0201_0300/s0232_implement_queue_using_stacks/readme.md

@@ -22,7 +22,14 @@ Implement the `MyQueue` class:
 
 **Output:** \[null, null, null, 1, 1, false\]
 
-**Explanation:** MyQueue myQueue = new MyQueue(); myQueue.push(1); // queue is: \[1\] myQueue.push(2); // queue is: \[1, 2\] (leftmost is front of the queue) myQueue.peek(); // return 1 myQueue.pop(); // return 1, queue is \[2\] myQueue.empty(); // return false 
+**Explanation:**
+
+    MyQueue myQueue = new MyQueue();
+    myQueue.push(1); // queue is: [1]
+    myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
+    myQueue.peek(); // return 1
+    myQueue.pop(); // return 1, queue is [2]
+    myQueue.empty(); // return false 
 
 **Constraints:**
 

src/test/java/g0201_0300/s0225_implement_stack_using_queues/MyStackTest.java

@@ -11,10 +11,8 @@ public void stackUsingQueue() {
         MyStack stack = new MyStack();
         stack.push(1);
         stack.push(2);
-        assertThat(stack.top, equalTo(2));
-
+        assertThat(stack.top(), equalTo(2));
         assertThat(stack.pop(), equalTo(2));
-
         assertThat(stack.empty(), equalTo(false));
     }
 }

src/test/java/g0201_0300/s0226_invert_binary_tree/SolutionTest.java

@@ -12,23 +12,17 @@ public void invertTree() {
         TreeNode leftBottomLeft = new TreeNode(1);
         TreeNode leftBottomRight = new TreeNode(3);
         TreeNode left = new TreeNode(2, leftBottomLeft, leftBottomRight);
-
         TreeNode rightBottomLeft = new TreeNode(6);
         TreeNode rightBottomRight = new TreeNode(9);
         TreeNode right = new TreeNode(7, rightBottomLeft, rightBottomRight);
-
         TreeNode root = new TreeNode(4, left, right);
-
         TreeNode leftBottomLeftInverted = new TreeNode(9);
         TreeNode leftBottomRightInverted = new TreeNode(6);
         TreeNode leftInverted = new TreeNode(7, leftBottomLeftInverted, leftBottomRightInverted);
-
         TreeNode rightBottomLeftInverted = new TreeNode(3);
         TreeNode rightBottomRightInverted = new TreeNode(1);
         TreeNode rightInverted = new TreeNode(2, rightBottomLeftInverted, rightBottomRightInverted);
-
         TreeNode rootInverted = new TreeNode(4, leftInverted, rightInverted);
-
         assertThat(new Solution().invertTree(root).toString(), equalTo(rootInverted.toString()));
     }
 }

src/test/java/g0201_0300/s0230_kth_smallest_element_in_a_bst/SolutionTest.java

@@ -12,10 +12,8 @@ public class SolutionTest {
     public void kthSmallest() {
         TreeNode rightBottomLeft = new TreeNode(2);
         TreeNode left = new TreeNode(1, null, rightBottomLeft);
-
         TreeNode right = new TreeNode(4);
         TreeNode root = new TreeNode(3, left, right);
-
         assertThat(new Solution().kthSmallest(root, 1), equalTo(1));
     }
 }

src/test/java/g0201_0300/s0232_implement_queue_using_stacks/MyQueueTest.java

@@ -11,7 +11,6 @@ public void queueUsingStacks() {
         MyQueue myQueue = new MyQueue();
         myQueue.push(1);
         myQueue.push(2);
-
         assertThat(myQueue.peek(), equalTo(1));
         assertThat(myQueue.pop(), equalTo(1));
         assertThat(myQueue.empty(), equalTo(false));