Some minor improvements

Author: rampatra

Diff for: src/main/java/com/ctci/treesandgraphs/CheckBalanced.java

@@ -57,7 +57,7 @@ private static int checkHeightAndBalance(TreeNode node) {
         return Math.max(leftHeight, rightHeight) + 1;
     }
 
-    private static boolean isBalancedOptimized(TreeNode node) {
+    public static boolean isBalancedOptimized(TreeNode node) {
         return checkHeightAndBalance(node) != Integer.MIN_VALUE;
     }
 

Diff for: src/main/java/com/rampatra/arrays/SortedSubSequence.java

@@ -5,7 +5,6 @@
  *
  * @author rampatra
  * @since 10/12/15
- * @time: 8:32 PM
  */
 public class SortedSubSequence {
 
@@ -19,36 +18,36 @@ public class SortedSubSequence {
      * 2) Create another auxiliary array greater[0..n-1]. greater[i] should store the index of a number which is greater than arr[i] and is on right side of arr[i]. greater[i] should contain -1 if there is no such element.
      * 3) Finally traverse both smaller[] and greater[] and find the index i for which both smaller[i] and greater[i] are not -1.
      *
-     * @param a
+     * @param arr
      */
-    public static void printSortedSubSequenceOfSize3(int[] a) {
-        int len = a.length, min = a[0], max = a[len - 1];
+    public static void printSortedSubSequenceOfSize3(int[] arr) {
+        int len = arr.length, min = arr[0], max = arr[len - 1];
 
         int[] smaller = new int[len], larger = new int[len];
 
         smaller[0] = -1;
         for (int i = 1; i < len; i++) {
-            if (a[i] < min) {
+            if (arr[i] < min) {
                 smaller[i] = -1;
-                min = a[i];
+                min = arr[i];
             } else {
                 smaller[i] = min;
             }
         }
 
         larger[len - 1] = -1;
         for (int i = len - 2; i >= 0; i--) {
-            if (a[i] > max) {
+            if (arr[i] > max) {
                 larger[i] = -1;
-                max = a[i];
+                max = arr[i];
             } else {
                 larger[i] = max;
             }
         }
 
         for (int i = 0; i < len; i++) {
             if (smaller[i] != -1 && larger[i] != -1) {
-                System.out.println(smaller[i] + "," + a[i] + "," + larger[i]);
+                System.out.println(smaller[i] + "," + arr[i] + "," + larger[i]);
                 break;
             }
         }

Diff for: src/main/java/com/rampatra/trees/HeightBalanced.java

@@ -1,5 +1,6 @@
 package com.rampatra.trees;
 
+import com.ctci.treesandgraphs.TreeNode;
 import com.rampatra.base.BinaryNode;
 import com.rampatra.base.BinarySearchTree;
 
@@ -19,7 +20,11 @@ public class HeightBalanced<E extends Comparable<E>> extends BinarySearchTree<E>
      * 1) Left subtree of T is balanced
      * 2) Right subtree of T is balanced
      * 3) The difference between heights of left subtree and right subtree is not more than 1.
-     *
+     * 
+     * This approach is simple but we are traversing each node multiple times while calculating the height. For a more
+     * optimized approach see {@link com.ctci.treesandgraphs.CheckBalanced#isBalancedOptimized(TreeNode)} where while
+     * calculating the height of tree we check whether it is balanced or not simultaneously.
+     * 
      * @return True if tree is height balanced otherwise false.
      */
     public boolean isHeightBalanced() {