Update

Author: ex01tus

src/array/MoveZeroes.java

@@ -0,0 +1,31 @@
+package array;
+
+/**
+ * Description: https://leetcode.com/problems/move-zeroes
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class MoveZeroes {
+
+    public void moveZeroes(int[] nums) {
+        int zero = 0;
+        int nonZero = 0;
+
+        while (nonZero < nums.length) {
+            if (nums[nonZero] == 0) {
+                nonZero++;
+            } else {
+                swap(nums, zero, nonZero);
+                zero++;
+                nonZero++;
+            }
+        }
+    }
+
+    private void swap(int[] nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+}

src/array/SquaresOfSortedArray.java

@@ -0,0 +1,29 @@
+package array;
+
+/**
+ * Description: https://leetcode.com/problems/squares-of-a-sorted-array
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class SquaresOfSortedArray {
+
+    public int[] sortedSquares(int[] nums) {
+        int[] squares = new int[nums.length];
+
+        int left = 0;
+        int right = nums.length - 1;
+
+        for (int i = nums.length - 1; i >= 0; i--) {
+            if (Math.abs(nums[right]) >= Math.abs(nums[left])) {
+                squares[i] = nums[right] * nums[right];
+                right--;
+            } else {
+                squares[i] = nums[left] * nums[left];
+                left++;
+            }
+        }
+
+        return squares;
+    }
+}

src/binary/CountingBits.java

@@ -0,0 +1,24 @@
+package binary;
+
+/**
+ * Description: https://leetcode.com/problems/counting-bits
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class CountingBits {
+
+    public int[] countBits(int n) {
+        int[] dp = new int[n + 1];
+        for (int i = 0; i <= n; i++) {
+            /*
+            1. Unit digit of even numbers is always '0': 2 -> 10, 4 -> 100, 6 -> 110, 8 -> 1000
+            2. Thus number of '1's for N and N / 2 is equal: 6 -> 110 && 3 -> 11, 10 -> 1010 && 5 -> 101
+            3. For odd numbers one more '1' is added: 10 -> 1010 && 11 -> 1011, 2 -> 10 && 3 -> 11
+             */
+            dp[i] = dp[i / 2] + (i % 2);
+        }
+
+        return dp;
+    }
+}

src/binary_search/SubtreeOfAnotherTree.java

@@ -0,0 +1,37 @@
+package binary_search;
+
+/**
+ * Description: https://leetcode.com/problems/subtree-of-another-tree
+ * Difficulty: Easy
+ * Time complexity: O(m * n)
+ * Space complexity: O(h2)
+ */
+public class SubtreeOfAnotherTree {
+
+    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
+        if (root == null) return false;
+        if (isEqual(root, subRoot)) return true;
+
+        boolean left = isSubtree(root.left, subRoot);
+        boolean right = isSubtree(root.right, subRoot);
+
+        return left || right;
+    }
+
+    private boolean isEqual(TreeNode first, TreeNode second) {
+        if (first == null && second == null) return true;
+        if (first == null || second == null) return false;
+        if (first.val != second.val) return false;
+
+        boolean left = isEqual(first.left, second.left);
+        boolean right = isEqual(first.right, second.right);
+
+        return left && right;
+    }
+
+    private static class TreeNode {
+        TreeNode left;
+        TreeNode right;
+        int val;
+    }
+}

src/binary_search_tree/ConvertSortedArrayToBinarySearchTree.java

@@ -0,0 +1,35 @@
+package binary_search_tree;
+
+/**
+ * Description: https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(log n)
+ */
+public class ConvertSortedArrayToBinarySearchTree {
+
+    public TreeNode sortedArrayToBST(int[] nums) {
+        return toBST(nums, 0, nums.length - 1);
+    }
+
+    private TreeNode toBST(int[] nums, int left, int right) {
+        if (left > right) return null;
+
+        int mid = left + (right - left) / 2;
+        TreeNode root = new TreeNode(nums[mid]);
+        root.left = toBST(nums, left, mid - 1);
+        root.right = toBST(nums, mid + 1, right);
+
+        return root;
+    }
+
+    private static class TreeNode {
+        TreeNode right;
+        TreeNode left;
+        int val;
+
+        public TreeNode(int val) {
+            this.val = val;
+        }
+    }
+}

src/binary_search_tree/LowestCommonAncestorOfBinarySearchTree.java

@@ -3,8 +3,8 @@
 /**
  * Description: https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree
  * Difficulty: Medium
- * Time complexity: O(log n)
- * Space complexity: O(log n)
+ * Time complexity: O(h)
+ * Space complexity: O(h)
  */
 public class LowestCommonAncestorOfBinarySearchTree {
 

src/binary_search_tree/ValidateBinarySearchTree.java

@@ -4,7 +4,7 @@
  * Description: https://leetcode.com/problems/validate-binary-search-tree
  * Difficulty: Medium
  * Time complexity: O(n)
- * Space complexity: O(n)
+ * Space complexity: O(h)
  */
 public class ValidateBinarySearchTree {
 

src/binary_tree/SameTree.java

@@ -0,0 +1,27 @@
+package binary_tree;
+
+/**
+ * Description: https://leetcode.com/problems/same-tree
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(h)
+ */
+public class SameTree {
+
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        if (p == null && q == null) return true;
+        if (p == null || q == null) return false;
+        if (p.val != q.val) return false;
+
+        boolean left = isSameTree(p.left, q.left);
+        boolean right = isSameTree(p.right, q.right);
+
+        return left && right;
+    }
+
+    private static class TreeNode {
+        TreeNode left;
+        TreeNode right;
+        int val;
+    }
+}

src/binary_tree/SymmetricTree.java

@@ -0,0 +1,29 @@
+package binary_tree;
+
+/**
+ * Description: https://leetcode.com/problems/symmetric-tree
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(log n)
+ */
+public class SymmetricTree {
+
+    public boolean isSymmetric(TreeNode root) {
+        return isMirror(root.left, root.right);
+    }
+
+    private boolean isMirror(TreeNode left, TreeNode right) {
+        if (left == null && right == null) return true;
+        if (left == null || right == null) return false;
+        if (left.val != right.val) return false;
+
+        return isMirror(left.left, right.right)
+                && isMirror(left.right, right.left);
+    }
+
+    private static class TreeNode {
+        TreeNode left;
+        TreeNode right;
+        int val;
+    }
+}

src/dynamic_programming/ClimbingStairs.java

@@ -13,19 +13,19 @@ public class ClimbingStairs {
      * Time complexity: O(n)
      * Space complexity: O(n)
      */
-    public int climbStairsWithMemoization(int n) {
-        Map<Integer, Integer> memo = new HashMap<>();
-        memo.put(1, 1);
-        memo.put(2, 2);
+    public int climbStairsViaDP(int n) {
+        Map<Integer, Integer> dp = new HashMap<>();
+        dp.put(1, 1);
+        dp.put(2, 2);
 
-        return count(n, memo);
+        return count(n, dp);
     }
 
-    private int count(int n, Map<Integer, Integer> memo) {
-        if (memo.containsKey(n)) return memo.get(n);
+    private int count(int n, Map<Integer, Integer> dp) {
+        if (dp.containsKey(n)) return dp.get(n);
 
-        int count = count(n - 1, memo) + count(n - 2, memo);
-        memo.put(n, count);
+        int count = count(n - 1, dp) + count(n - 2, dp);
+        dp.put(n, count);
 
         return count;
     }

src/dynamic_programming/CoinChange.java

@@ -14,25 +14,25 @@ public class CoinChange {
     public int coinChange(int[] coins, int amount) {
         if (amount < 1) return 0;
 
-        Map<Integer, Integer> memo = new HashMap<>();
-        memo.put(0, 0);
+        Map<Integer, Integer> dp = new HashMap<>();
+        dp.put(0, 0);
 
         for (int currentAmount = 1; currentAmount <= amount; currentAmount++) {
             int count = Integer.MAX_VALUE;
 
             for (int coin : coins) {
                 if (currentAmount - coin < 0) continue;
 
-                if (memo.get(currentAmount - coin) != null) {
-                    count = Math.min(memo.get(currentAmount - coin) + 1, count);
+                if (dp.get(currentAmount - coin) != null) {
+                    count = Math.min(dp.get(currentAmount - coin) + 1, count);
                 }
             }
 
             if (count != Integer.MAX_VALUE) {
-                memo.put(currentAmount, count);
+                dp.put(currentAmount, count);
             }
         }
 
-        return memo.getOrDefault(amount, -1);
+        return dp.getOrDefault(amount, -1);
     }
 }

src/dynamic_programming/CoinChange2.java

@@ -9,16 +9,16 @@
 public class CoinChange2 {
 
     public int change(int amount, int[] coins) {
-        int[] memo = new int[amount + 1];
-        memo[0] = 1;
+        int[] dp = new int[amount + 1];
+        dp[0] = 1;
 
         for (int coin : coins) {
             for (int i = coin; i <= amount; i++) {
                 int prev = i - coin;
-                memo[i] += memo[prev];
+                dp[i] += dp[prev];
             }
         }
 
-        return memo[amount];
+        return dp[amount];
     }
 }

src/dynamic_programming/LongestCommonSubsequence.java

@@ -9,21 +9,21 @@
 public class LongestCommonSubsequence {
 
     public int longestCommonSubsequence(String text1, String text2) {
-        int[][] memo = new int[text1.length()][text2.length()];
+        int[][] dp = new int[text1.length()][text2.length()];
 
         for (int i = 0; i < text1.length(); i++) {
             for (int j = 0; j < text2.length(); j++) {
                 if (text1.charAt(i) == text2.charAt(j)) {
-                    int prev = (i > 0 && j > 0) ? memo[i - 1][j - 1] : 0;
-                    memo[i][j] = prev + 1;
+                    int prev = (i > 0 && j > 0) ? dp[i - 1][j - 1] : 0;
+                    dp[i][j] = prev + 1;
                 } else {
-                    int prev1 = i > 0 ? memo[i - 1][j] : 0;
-                    int prev2 = j > 0 ? memo[i][j - 1] : 0;
-                    memo[i][j] = Math.max(prev1, prev2);
+                    int prev1 = i > 0 ? dp[i - 1][j] : 0;
+                    int prev2 = j > 0 ? dp[i][j - 1] : 0;
+                    dp[i][j] = Math.max(prev1, prev2);
                 }
             }
         }
 
-        return memo[text1.length() - 1][text2.length() - 1];
+        return dp[text1.length() - 1][text2.length() - 1];
     }
 }