basics

Author: idf

src/BinaryTreeLevelOrderTraversal/Solution.java

@@ -0,0 +1,57 @@
+package BinaryTreeLevelOrderTraversal;
+
+import commons.datastructures.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * User: Danyang
+ * Date: 1/27/2015
+ * Time: 14:56
+ *
+ * Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).
+
+ For example:
+ Given binary tree {3,9,20,#,#,15,7},
+  3
+ / \
+ 9  20
+ /  \
+ 15   7
+ return its level order traversal as:
+ [
+ [3],
+ [9,20],
+ [15,7]
+ ]
+ */
+public class Solution {
+    /**
+     * bfs
+     * @param root
+     * @return
+     */
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> ret = new ArrayList<>();
+        if(root==null)
+            return ret;
+
+        TreeNode cur = root;
+        List<TreeNode> q = new ArrayList<>();
+        q.add(cur);
+        while(!q.isEmpty()) {
+            int l = q.size();
+            List<Integer> currentLevel = new ArrayList<>();
+            for(int i=0; i<l; i++) {
+                cur = q.get(i);
+                currentLevel.add(cur.val);
+                if(cur.left!=null) q.add(cur.left);
+                if(cur.right!=null) q.add(cur.right);
+            }
+            ret.add(currentLevel);
+            q = q.subList(l, q.size());  // similar API as python
+        }
+        return ret;
+    }
+}

src/BinaryTreeLevelOrderTraversalII/Solution.java

@@ -0,0 +1,57 @@
+package BinaryTreeLevelOrderTraversalII;
+
+import commons.datastructures.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * User: Danyang
+ * Date: 1/27/2015
+ * Time: 15:03
+ * Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level
+ * by level from leaf to root).
+
+ For example:
+ Given binary tree {3,9,20,#,#,15,7},
+  3
+ / \
+ 9  20
+ /  \
+ 15   7
+ return its bottom-up level order traversal as:
+ [
+ [15,7],
+ [9,20],
+ [3]
+ ]
+ */
+public class Solution {
+    /**
+     * bfs
+     * @param root
+     * @return
+     */
+    public List<List<Integer>> levelOrderBottom(TreeNode root) {
+        List<List<Integer>> ret = new ArrayList<>();
+        List<TreeNode> q = new ArrayList<>();
+        if(root==null)
+            return ret;
+
+        TreeNode cur = root;
+        q.add(cur);
+        while(!q.isEmpty()) {
+            int l = q.size();
+            List<Integer> level = new ArrayList<>();
+            for(int i=0; i<l; i++) {
+                cur = q.get(i);
+                level.add(cur.val);
+                if(cur.left!=null) q.add(cur.left);
+                if(cur.right!=null) q.add(cur.right);
+            }
+            ret.add(0, level);
+            q = q.subList(l, q.size());
+        }
+        return ret;
+    }
+}

src/MaximumDepthofBinaryTree/Solution.java

@@ -0,0 +1,28 @@
+package MaximumDepthofBinaryTree;
+
+import commons.datastructures.TreeNode;
+
+/**
+ * User: Danyang
+ * Date: 1/27/2015
+ * Time: 15:17
+ *
+ * Given a binary tree, find its maximum depth.
+
+ The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
+ */
+public class Solution {
+    public int maxDepth(TreeNode root) {
+        if(root==null)
+            return 0;
+        return getDepth(root, 1);
+    }
+
+    int getDepth(TreeNode cur, int depth) {
+        if(cur==null)
+            return Integer.MIN_VALUE;
+        if(cur.left==null && cur.right==null)
+            return depth;
+        return Math.max(getDepth(cur.left, depth+1), getDepth(cur.right, depth+1));
+    }
+}

src/MinimumDepthofBinaryTree/Solution.java

@@ -0,0 +1,35 @@
+package MinimumDepthofBinaryTree;
+
+import commons.datastructures.TreeNode;
+
+/**
+ * User: Danyang
+ * Date: 1/27/2015
+ * Time: 15:11
+ *
+ * Given a binary tree, find its minimum depth.
+
+ The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.
+
+ */
+public class Solution {
+    /**
+     * Notice:
+     * 1. must be leaf node
+     * @param root
+     * @return
+     */
+    public int minDepth(TreeNode root) {
+        if(root==null)
+            return 0;
+        return getDepth(root, 1);
+    }
+
+    int getDepth(TreeNode cur, int depth) {
+        if(cur==null)
+            return Integer.MAX_VALUE;
+        if(cur.left==null && cur.right==null)
+            return depth;
+        return Math.min(getDepth(cur.left, depth+1), getDepth(cur.right, depth+1));
+    }
+}