add Sliding window maximum, Count Univalue Subtrees, Group Shifted Strings

Author: FreeTymeKiyan

src/main/java/com/freetymekiyan/algorithms/level/easy/LowestCommonAncestorOfABinarySearchTree.java

@@ -0,0 +1,77 @@
+package com.freetymekiyan.algorithms.level.easy;
+
+import com.freetymekiyan.algorithms.utils.Utils.TreeNode;
+
+/**
+ * 235. Lowest Common Ancestor of a Binary Search Tree
+ * <p>
+ * Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.
+ * <p>
+ * According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as
+ * the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”
+ * |
+ * |           _______6______
+ * |          /              \
+ * |      ___2__          ___8__
+ * |     /      \        /      \
+ * |    0      _4       7       9
+ * |          /  \
+ * |         3   5
+ * |
+ * For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6.
+ * <p>
+ * Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA
+ * definition.
+ * <p>
+ * Company Tags: Amazon, Microsoft, Facebook, Twitter
+ * Tags: Tree
+ * Similar Problems: (M) Lowest Common Ancestor of a Binary Tree
+ */
+public class LowestCommonAncestorOfABinarySearchTree {
+
+  /**
+   * Iterative.
+   * In BST, the lca's value can only be [p, q].
+   * And lca is the first from top to bottom that lies in range.
+   * If the value is less than both p and q's values, move to right subtree.
+   * If the value is more than both p and q's values, move to left subtree.
+   * If the value is in between the two nodes, return the node.
+   * Otherwise there is no LCA.
+   */
+  public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+    while (root != null) {
+      if (root.val < p.val && root.val < q.val) {
+        root = root.right;
+      } else if (root.val > p.val && root.val > q.val) {
+        root = root.left;
+      } else {
+        return root;
+      }
+    }
+    return null; // Reach null and lca not found.
+  }
+
+  /**
+   * Recursion.
+   * LCA's value must be between [p, q].
+   * Recurrent relation:
+   * If root's value < p's and q's, LCA is in the right subtree.
+   * If root's value > p's and q's, LCA is in the left subtree.
+   * Else, root's value in between, LCA is root.
+   * Base case:
+   * If root is null, return null.
+   * Complete task:
+   * Deal with base case. Search left, search right. Return result.
+   */
+  public TreeNode lowestCommonAncestorB(TreeNode root, TreeNode p, TreeNode q) {
+    if (root == null) {
+      return null;
+    }
+    if (root.val < p.val && root.val < q.val) {
+      return lowestCommonAncestorB(root.right, p, q);
+    } else if (root.val > p.val && root.val > q.val) {
+      return lowestCommonAncestorB(root.left, p, q);
+    }
+    return root; // root's value in between p and q.
+  }
+}

src/main/java/com/freetymekiyan/algorithms/level/easy/LowestCommonAncestorOfBST.java

@@ -16,60 +16,60 @@
  */
 public class PalindromeLinkedList {
 
-    /**
-     * Two Pointers.
-     * Find the middle node, reverse the right half list, then check each node.
-     * Use two pointers, one slow pointer s, one fast pointer f.
-     * Move s to the head of the right half list.
-     * If there are odd number of nodes, move s one step further.
-     * Reverse the right half of the list starting from s.
-     * Then compare each node's value while s is not null.
-     * If diff, return false. Else continue.
-     * After all nodes checked, return true.
-     */
-    public boolean isPalindrome(ListNode head) {
-        if (head == null || head.next == null) {
-            return true;
-        }
-        ListNode slow = head;
-        ListNode fast = head;
-        while (fast != null && fast.next != null) {
-            slow = slow.next;
-            fast = fast.next.next;
-        }
-        if (fast != null) { // Odd # of nodes. Make sure slow is always the head of right half.
-            slow = slow.next;
-        }
-        slow = reverseList(slow); // Reverse the right half of the list.
-        ListNode cur = head;
-        while (slow != null) { // Slow can reach tail early.
-            if (cur.val != slow.val) {
-                return false;
-            }
-            cur = cur.next;
-            slow = slow.next;
-        }
-        return true;
+  /**
+   * Two Pointers.
+   * Find the middle node, reverse the right half list, then check each node.
+   * Use two pointers, one slow pointer s, one fast pointer f.
+   * Move s to the head of the right half list.
+   * If there are odd number of nodes, move s one step further.
+   * Reverse the right half of the list starting from s.
+   * Then compare each node's value while s is not null.
+   * If diff, return false. Else continue.
+   * After all nodes checked, return true.
+   */
+  public boolean isPalindrome(ListNode head) {
+    if (head == null || head.next == null) {
+      return true;
     }
+    ListNode slow = head;
+    ListNode fast = head;
+    while (fast != null && fast.next != null) {
+      slow = slow.next;
+      fast = fast.next.next;
+    }
+    if (fast != null) { // Odd # of nodes. Make sure slow is always the head of right half.
+      slow = slow.next;
+    }
+    slow = reverseList(slow); // Reverse the right half of the list.
+    ListNode cur = head;
+    while (slow != null) { // Slow can reach tail early.
+      if (cur.val != slow.val) {
+        return false;
+      }
+      cur = cur.next;
+      slow = slow.next;
+    }
+    return true;
+  }
 
-    /**
-     * Iterative.
-     * Create a new head as null, which will be the tail of the reversed list.
-     * While head is not null:
-     * | Store the next node.
-     * | Reverse head.
-     * | Update new head.
-     * | Move to next.
-     * Return new head.
-     */
-    private ListNode reverseList(ListNode head) {
-        ListNode newHead = null;
-        while (head != null) {
-            ListNode next = head.next;
-            head.next = newHead;
-            newHead = head;
-            head = next;
-        }
-        return newHead;
+  /**
+   * Iterative.
+   * Create a new head as null, which will be the tail of the reversed list.
+   * While head is not null:
+   * | Store the next node.
+   * | Reverse head.
+   * | Update new head.
+   * | Move to next.
+   * Return new head.
+   */
+  private ListNode reverseList(ListNode head) {
+    ListNode newHead = null;
+    while (head != null) {
+      ListNode next = head.next;
+      head.next = newHead;
+      newHead = head;
+      head = next;
     }
+    return newHead;
+  }
 }

src/main/java/com/freetymekiyan/algorithms/level/easy/PalindromeLinkedList.java

@@ -1,26 +1,28 @@
 package com.freetymekiyan.algorithms.level.easy;
 
 /**
+ * 231. Power of Two
+ * <p>
  * Given an integer, write a function to determine if it is a power of two.
  * <p>
  * Tags: Math, Bit Manipulation
  * Similar Problems: (E) Number of 1 Bits, (E) Power of Three, (E) Power of Four
  */
 public class PowerOfTwo {
 
-    /**
-     * 2's power only has a single 1 at the highest bit.
-     * So n & (n - 1) should be 0.
-     * Check also if n is positive.
-     */
-    public boolean isPowerOfTwo(int n) {
-        return n > 0 && (n & (n - 1)) == 0;
-    }
+  /**
+   * 2's power only has a single 1 at the highest bit.
+   * So n & (n - 1) should be 0.
+   * Check also if n is positive.
+   */
+  public boolean isPowerOfTwo(int n) {
+    return n > 0 && (n & (n - 1)) == 0;
+  }
 
-    /**
-     * One-liner using Integer.bitCount because only a single bit should be 1 for 2's power.
-     */
-    public boolean isPowerOfTwoB(int n) {
-        return n > 0 && Integer.bitCount(n) == 1;
-    }
+  /**
+   * One-liner using Integer.bitCount because only a single bit should be 1 for 2's power.
+   */
+  public boolean isPowerOfTwoB(int n) {
+    return n > 0 && Integer.bitCount(n) == 1;
+  }
 }

src/main/java/com/freetymekiyan/algorithms/level/easy/PowerOfTwo.java

@@ -15,27 +15,27 @@
  */
 public class StrobogrammaticNumber {
 
-    /**
-     * Math.
-     * Take a look at all digits from 0 to 9.
-     * 0,1,8 are strobogrammatic no matter what.
-     * 6 and 9 can form a strobogrammatic pair, which means they must be center symmetrical.
-     * Other digits just cannot be strobogrammatic.
-     */
-    public boolean isStrobogrammatic(String num) {
-        int len = num.length() / 2;
-        for (int i = 0; i < len; i++) {
-            char d = num.charAt(i);
-            if (d == '0' || d == '1' || d == '8') {
-                continue;
-            } else if (d == '6') {
-                if (num.charAt(num.length() - 1 - i) != '9') return false;
-            } else if (d == '9') {
-                if (num.charAt(num.length() - 1 - i) != '6') return false;
-            } else {
-                return false;
-            }
-        }
-        return true;
+  /**
+   * Math.
+   * Take a look at all digits from 0 to 9.
+   * 0,1,8 are strobogrammatic no matter what.
+   * 6 and 9 can form a strobogrammatic pair, which means they must be center symmetrical.
+   * Other digits just cannot be strobogrammatic.
+   */
+  public boolean isStrobogrammatic(String num) {
+    int len = num.length() / 2;
+    for (int i = 0; i < len; i++) {
+      char d = num.charAt(i);
+      if (d == '0' || d == '1' || d == '8') {
+        continue;
+      } else if (d == '6') {
+        if (num.charAt(num.length() - 1 - i) != '9') return false;
+      } else if (d == '9') {
+        if (num.charAt(num.length() - 1 - i) != '6') return false;
+      } else {
+        return false;
+      }
     }
+    return true;
+  }
 }