Add Binary Tree problems

Author: andrewbayd

src/com/andrewbayd/BalancedBinaryTree.java

@@ -0,0 +1,26 @@
+package com.andrewbayd;
+
+import com.andrewbayd.datastructures.TreeNode;
+
+/*
+Given a binary tree, determine if it is height-balanced.
+
+https://leetcode.com/problems/balanced-binary-tree/
+ */
+
+public class BalancedBinaryTree {
+    public boolean isBalanced(TreeNode root) {
+        return height(root) != -1;
+    }
+
+    private int height(TreeNode node) {
+        if (node == null) return 0;
+
+        int leftHeight = height(node.left);
+        int rightHeight = height(node.right);
+
+        if (leftHeight == -1 || rightHeight == -1 || Math.abs(leftHeight - rightHeight) > 1) return -1;
+
+        return Math.max(leftHeight, rightHeight) + 1;
+    }
+}

src/com/andrewbayd/BinaryTreeInOrderTraversal.java

@@ -1,4 +1,6 @@
-package com.andrewbayd.binaryTreeInOrderTraversal;
+package com.andrewbayd;
+
+import com.andrewbayd.datastructures.TreeNode;
 
 import java.util.ArrayList;
 import java.util.List;

src/com/andrewbayd/BinaryTreeLCA.java

@@ -0,0 +1,22 @@
+package com.andrewbayd;
+
+import com.andrewbayd.datastructures.TreeNode;
+
+/*
+Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.
+
+https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/
+ */
+public class BinaryTreeLCA {
+    public static TreeNode lca(TreeNode root, TreeNode node1, TreeNode node2) {
+        if (root == null) return null;
+        if (root.equals(node1) || root.equals(node2)) return root;
+
+        TreeNode leftLCA = lca(root.left, node1, node2);
+        TreeNode rightLCA = lca(root.right, node1, node2);
+
+        if (leftLCA != null && rightLCA != null) return root;
+        if (leftLCA != null) return leftLCA;
+        return rightLCA;
+    }
+}

src/com/andrewbayd/BinaryTreeLevelOrderTraversal.java

@@ -0,0 +1,33 @@
+package com.andrewbayd;
+
+import com.andrewbayd.datastructures.TreeNode;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.List;
+
+/*
+Given the root of a binary tree, return the level order traversal of its nodes' values.
+
+https://leetcode.com/problems/binary-tree-level-order-traversal/
+ */
+public class BinaryTreeLevelOrderTraversal {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>();
+        ArrayDeque<TreeNode> q = new ArrayDeque<>();
+
+        if (root != null) q.add(root);
+        while (!q.isEmpty()) {
+            List<Integer> levelItems = new ArrayList<>();
+            int levelSize = q.size();
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode current = q.poll();
+                if (current.left != null) q.add(current.left);
+                if (current.right != null) q.add(current.right);
+                levelItems.add(current.val);
+            }
+            result.add(levelItems);
+        }
+        return result;
+    }
+}

src/com/andrewbayd/BinaryTreeZigZagLevelTraversal.java

@@ -0,0 +1,39 @@
+package com.andrewbayd;
+
+import com.andrewbayd.datastructures.TreeNode;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.List;
+
+/*
+Given the root of a binary tree, return the zigzag level order traversal of its nodes' values. (i.e., from left to right, then right to left for the next level and alternate between).
+
+https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/
+ */
+public class BinaryTreeZigZagLevelTraversal {
+    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>();
+        ArrayDeque<TreeNode> q = new ArrayDeque<>();
+
+        if (root != null) q.add(root);
+        while (!q.isEmpty()) {
+            List<Integer> levelItems = new ArrayList<>();
+            int levelSize = q.size();
+            boolean isReversed = result.size() % 2 != 0;
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode current = isReversed ? q.pollLast() : q.pollFirst();
+                levelItems.add(current.val);
+                if (isReversed) {
+                    if (current.right != null) q.addFirst(current.right);
+                    if (current.left != null) q.addFirst(current.left);
+                } else {
+                    if (current.left != null) q.addLast(current.left);
+                    if (current.right != null) q.addLast(current.right);
+                }
+            }
+            result.add(levelItems);
+        }
+        return result;
+    }
+}

src/com/andrewbayd/GoodNodesInBinaryTree.java

@@ -0,0 +1,27 @@
+package com.andrewbayd;
+
+import com.andrewbayd.datastructures.TreeNode;
+
+/*
+Given a binary tree root, a node X in the tree is named good if in the path from root to X there are no nodes with a value greater than X.
+Return the number of good nodes in the binary tree.
+
+https://leetcode.com/problems/count-good-nodes-in-binary-tree/
+ */
+public class GoodNodesInBinaryTree {
+    public int goodNodes(TreeNode root) {
+        return dfs(root, root.val);
+    }
+
+    private int dfs(TreeNode root, int max) {
+        if (root == null) return 0;
+        int count = 0;
+        if (root.val >= max) {
+            count++;
+            max = root.val;
+        }
+        count += dfs(root.left, max);
+        count += dfs(root.right, max);
+        return count;
+    }
+}

src/com/andrewbayd/InsertIntoBST.java

@@ -0,0 +1,18 @@
+package com.andrewbayd;
+
+import com.andrewbayd.datastructures.TreeNode;
+
+/*
+You are given the root node of a binary search tree (BST) and a value to insert into the tree.
+Return the root node of the BST after the insertion.
+
+https://leetcode.com/problems/insert-into-a-binary-search-tree/
+ */
+public class InsertIntoBST {
+    public TreeNode insertIntoBST(TreeNode root, int val) {
+        if (root == null) return new TreeNode(val);
+        if (val < root.val) root.left = insertIntoBST(root.left, val);
+        if (val > root.val) root.right = insertIntoBST(root.right, val);
+        return root;
+    }
+}

src/com/andrewbayd/MaxDepthBinaryTree.java

@@ -0,0 +1,18 @@
+package com.andrewbayd;
+
+import com.andrewbayd.datastructures.TreeNode;
+
+/*
+Given the root of a binary tree, return its maximum depth.
+A binary tree's maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
+
+https://leetcode.com/problems/maximum-depth-of-binary-tree/
+ */
+public class MaxDepthBinaryTree {
+    public int maxDepth(TreeNode root) {
+        if (root == null) return 0;
+        int leftDepth = maxDepth(root.left) ;
+        int rightDepth = maxDepth(root.right);
+        return Math.max(leftDepth, rightDepth) + 1;
+    }
+}

src/com/andrewbayd/SerializeDeserializeBST.java

@@ -0,0 +1,51 @@
+package com.andrewbayd;
+
+import com.andrewbayd.datastructures.TreeNode;
+
+import java.util.Arrays;
+import java.util.Iterator;
+
+/*
+Design an algorithm to serialize and deserialize a binary search tree.
+
+https://leetcode.com/problems/serialize-and-deserialize-bst/
+ */
+
+public class SerializeDeserializeBST {
+
+    // Encodes a tree to a single string.
+    public String serialize(TreeNode root) {
+        StringBuilder result = new StringBuilder();
+        serializeRecursive(root, result);
+        return result.toString().trim();
+    }
+
+    private void serializeRecursive(TreeNode root, StringBuilder str) {
+        if (root == null) {
+            str.append("x ");
+            return;
+        }
+        str.append(root.val).append(" ");
+        serializeRecursive(root.left, str);
+        serializeRecursive(root.right, str);
+    }
+
+    // Decodes your encoded data to tree.
+    public TreeNode deserialize(String data) {
+        return deserializeRecursive(Arrays.asList(data.split(" ")).iterator());
+    }
+
+    private TreeNode deserializeRecursive(Iterator<String> data) {
+        String current = data.next();
+
+        if (current.equals("x")) {
+            return null;
+        }
+
+        TreeNode root = new TreeNode(Integer.parseInt(current));
+        root.left = deserializeRecursive(data);
+        root.right = deserializeRecursive(data);
+
+        return root;
+    }
+}

src/com/andrewbayd/datastructures/TreeNode.java

@@ -6,14 +6,14 @@ public class TreeNode {
     public TreeNode left;
     public TreeNode right;
 
-    TreeNode() {
+    public TreeNode() {
     }
 
-    TreeNode(int val) {
+    public TreeNode(int val) {
         this.val = val;
     }
 
-    TreeNode(int val, TreeNode left, TreeNode right) {
+    public TreeNode(int val, TreeNode left, TreeNode right) {
         this.val = val;
         this.left = left;
         this.right = right;